src/Apache.IoTDB/Rpc/Generated/IClientRPCService.cs

/**
 * Autogenerated by Thrift Compiler (0.14.1)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Thrift;
using Thrift.Collections;

using Thrift.Protocol;
using Thrift.Protocol.Entities;
using Thrift.Protocol.Utilities;
using Thrift.Transport;
using Thrift.Transport.Client;
using Thrift.Transport.Server;
using Thrift.Processor;


#pragma warning disable IDE0079  // remove unnecessary pragmas
#pragma warning disable IDE1006  // parts of the code use IDL spelling

public partial class IClientRPCService
{
  public interface IAsync
  {
    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeQueryStatementV2Async(TSExecuteStatementReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeUpdateStatementV2Async(TSExecuteStatementReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeStatementV2Async(TSExecuteStatementReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeRawDataQueryV2Async(TSRawDataQueryReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeLastDataQueryV2Async(TSLastDataQueryReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeFastLastDataQueryForOneDeviceV2Async(TSFastLastDataQueryForOneDeviceReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeAggregationQueryV2Async(TSAggregationQueryReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeGroupByQueryIntervalQueryAsync(TSGroupByQueryIntervalReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSFetchResultsResp> fetchResultsV2Async(TSFetchResultsReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSOpenSessionResp> openSessionAsync(TSOpenSessionReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> closeSessionAsync(TSCloseSessionReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeStatementAsync(TSExecuteStatementReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> executeBatchStatementAsync(TSExecuteBatchStatementReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeQueryStatementAsync(TSExecuteStatementReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeUpdateStatementAsync(TSExecuteStatementReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSFetchResultsResp> fetchResultsAsync(TSFetchResultsReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSFetchMetadataResp> fetchMetadataAsync(TSFetchMetadataReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> cancelOperationAsync(TSCancelOperationReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> closeOperationAsync(TSCloseOperationReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSGetTimeZoneResp> getTimeZoneAsync(long sessionId, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> setTimeZoneAsync(TSSetTimeZoneReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<ServerProperties> getPropertiesAsync(CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> setStorageGroupAsync(long sessionId, string storageGroup, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> createTimeseriesAsync(TSCreateTimeseriesReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> createAlignedTimeseriesAsync(TSCreateAlignedTimeseriesReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> createMultiTimeseriesAsync(TSCreateMultiTimeseriesReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> deleteTimeseriesAsync(long sessionId, List<string> path, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> deleteStorageGroupsAsync(long sessionId, List<string> storageGroup, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> insertRecordAsync(TSInsertRecordReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> insertStringRecordAsync(TSInsertStringRecordReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> insertTabletAsync(TSInsertTabletReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> insertTabletsAsync(TSInsertTabletsReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> insertRecordsAsync(TSInsertRecordsReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> insertRecordsOfOneDeviceAsync(TSInsertRecordsOfOneDeviceReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> insertStringRecordsOfOneDeviceAsync(TSInsertStringRecordsOfOneDeviceReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> insertStringRecordsAsync(TSInsertStringRecordsReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> testInsertTabletAsync(TSInsertTabletReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> testInsertTabletsAsync(TSInsertTabletsReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> testInsertRecordAsync(TSInsertRecordReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> testInsertStringRecordAsync(TSInsertStringRecordReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> testInsertRecordsAsync(TSInsertRecordsReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> testInsertRecordsOfOneDeviceAsync(TSInsertRecordsOfOneDeviceReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> testInsertStringRecordsAsync(TSInsertStringRecordsReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> deleteDataAsync(TSDeleteDataReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeRawDataQueryAsync(TSRawDataQueryReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeLastDataQueryAsync(TSLastDataQueryReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeAggregationQueryAsync(TSAggregationQueryReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<long> requestStatementIdAsync(long sessionId, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> createSchemaTemplateAsync(TSCreateSchemaTemplateReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> appendSchemaTemplateAsync(TSAppendSchemaTemplateReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> pruneSchemaTemplateAsync(TSPruneSchemaTemplateReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSQueryTemplateResp> querySchemaTemplateAsync(TSQueryTemplateReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TShowConfigurationTemplateResp> showConfigurationTemplateAsync(CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TShowConfigurationResp> showConfigurationAsync(int nodeId, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> setSchemaTemplateAsync(TSSetSchemaTemplateReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> unsetSchemaTemplateAsync(TSUnsetSchemaTemplateReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> dropSchemaTemplateAsync(TSDropSchemaTemplateReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> createTimeseriesUsingSchemaTemplateAsync(TCreateTimeseriesUsingSchemaTemplateReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> handshakeAsync(TSyncIdentityInfo info, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> sendPipeDataAsync(byte[] buff, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSStatus> sendFileAsync(TSyncTransportMetaInfo metaInfo, byte[] buff, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TPipeTransferResp> pipeTransferAsync(TPipeTransferReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TPipeSubscribeResp> pipeSubscribeAsync(TPipeSubscribeReq req, CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSBackupConfigurationResp> getBackupConfigurationAsync(CancellationToken cancellationToken = default);

    global::System.Threading.Tasks.Task<TSConnectionInfoResp> fetchAllConnectionsInfoAsync(CancellationToken cancellationToken = default);

    /// <summary>
    /// For other node's call
    /// </summary>
    global::System.Threading.Tasks.Task<TSStatus> testConnectionEmptyRPCAsync(CancellationToken cancellationToken = default);

  }


  public class Client : TBaseClient, IDisposable, IAsync
  {
    public Client(TProtocol protocol) : this(protocol, protocol)
    {
    }

    public Client(TProtocol inputProtocol, TProtocol outputProtocol) : base(inputProtocol, outputProtocol)    {
    }
    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeQueryStatementV2Async(TSExecuteStatementReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeQueryStatementV2", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeQueryStatementV2Args() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeQueryStatementV2Result();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeQueryStatementV2 failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeUpdateStatementV2Async(TSExecuteStatementReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeUpdateStatementV2", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeUpdateStatementV2Args() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeUpdateStatementV2Result();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeUpdateStatementV2 failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeStatementV2Async(TSExecuteStatementReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeStatementV2", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeStatementV2Args() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeStatementV2Result();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeStatementV2 failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeRawDataQueryV2Async(TSRawDataQueryReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeRawDataQueryV2", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeRawDataQueryV2Args() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeRawDataQueryV2Result();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeRawDataQueryV2 failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeLastDataQueryV2Async(TSLastDataQueryReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeLastDataQueryV2", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeLastDataQueryV2Args() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeLastDataQueryV2Result();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeLastDataQueryV2 failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeFastLastDataQueryForOneDeviceV2Async(TSFastLastDataQueryForOneDeviceReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeFastLastDataQueryForOneDeviceV2", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeFastLastDataQueryForOneDeviceV2Args() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeFastLastDataQueryForOneDeviceV2Result();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeFastLastDataQueryForOneDeviceV2 failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeAggregationQueryV2Async(TSAggregationQueryReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeAggregationQueryV2", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeAggregationQueryV2Args() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeAggregationQueryV2Result();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeAggregationQueryV2 failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeGroupByQueryIntervalQueryAsync(TSGroupByQueryIntervalReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeGroupByQueryIntervalQuery", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeGroupByQueryIntervalQueryArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeGroupByQueryIntervalQueryResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeGroupByQueryIntervalQuery failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSFetchResultsResp> fetchResultsV2Async(TSFetchResultsReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("fetchResultsV2", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.fetchResultsV2Args() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.fetchResultsV2Result();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "fetchResultsV2 failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSOpenSessionResp> openSessionAsync(TSOpenSessionReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("openSession", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.openSessionArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.openSessionResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "openSession failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> closeSessionAsync(TSCloseSessionReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("closeSession", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.closeSessionArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.closeSessionResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "closeSession failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeStatementAsync(TSExecuteStatementReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeStatement", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeStatementArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeStatementResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeStatement failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> executeBatchStatementAsync(TSExecuteBatchStatementReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeBatchStatement", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeBatchStatementArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeBatchStatementResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeBatchStatement failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeQueryStatementAsync(TSExecuteStatementReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeQueryStatement", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeQueryStatementArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeQueryStatementResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeQueryStatement failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeUpdateStatementAsync(TSExecuteStatementReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeUpdateStatement", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeUpdateStatementArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeUpdateStatementResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeUpdateStatement failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSFetchResultsResp> fetchResultsAsync(TSFetchResultsReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("fetchResults", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.fetchResultsArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.fetchResultsResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "fetchResults failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSFetchMetadataResp> fetchMetadataAsync(TSFetchMetadataReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("fetchMetadata", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.fetchMetadataArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.fetchMetadataResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "fetchMetadata failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> cancelOperationAsync(TSCancelOperationReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("cancelOperation", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.cancelOperationArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.cancelOperationResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "cancelOperation failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> closeOperationAsync(TSCloseOperationReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("closeOperation", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.closeOperationArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.closeOperationResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "closeOperation failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSGetTimeZoneResp> getTimeZoneAsync(long sessionId, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("getTimeZone", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.getTimeZoneArgs() {
        SessionId = sessionId,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.getTimeZoneResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getTimeZone failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> setTimeZoneAsync(TSSetTimeZoneReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("setTimeZone", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.setTimeZoneArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.setTimeZoneResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "setTimeZone failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<ServerProperties> getPropertiesAsync(CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("getProperties", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.getPropertiesArgs() {
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.getPropertiesResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getProperties failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> setStorageGroupAsync(long sessionId, string storageGroup, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("setStorageGroup", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.setStorageGroupArgs() {
        SessionId = sessionId,
        StorageGroup = storageGroup,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.setStorageGroupResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "setStorageGroup failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> createTimeseriesAsync(TSCreateTimeseriesReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("createTimeseries", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.createTimeseriesArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.createTimeseriesResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "createTimeseries failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> createAlignedTimeseriesAsync(TSCreateAlignedTimeseriesReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("createAlignedTimeseries", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.createAlignedTimeseriesArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.createAlignedTimeseriesResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "createAlignedTimeseries failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> createMultiTimeseriesAsync(TSCreateMultiTimeseriesReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("createMultiTimeseries", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.createMultiTimeseriesArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.createMultiTimeseriesResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "createMultiTimeseries failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> deleteTimeseriesAsync(long sessionId, List<string> path, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("deleteTimeseries", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.deleteTimeseriesArgs() {
        SessionId = sessionId,
        Path = path,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.deleteTimeseriesResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "deleteTimeseries failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> deleteStorageGroupsAsync(long sessionId, List<string> storageGroup, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("deleteStorageGroups", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.deleteStorageGroupsArgs() {
        SessionId = sessionId,
        StorageGroup = storageGroup,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.deleteStorageGroupsResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "deleteStorageGroups failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> insertRecordAsync(TSInsertRecordReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("insertRecord", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.insertRecordArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.insertRecordResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "insertRecord failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> insertStringRecordAsync(TSInsertStringRecordReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("insertStringRecord", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.insertStringRecordArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.insertStringRecordResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "insertStringRecord failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> insertTabletAsync(TSInsertTabletReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("insertTablet", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.insertTabletArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.insertTabletResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "insertTablet failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> insertTabletsAsync(TSInsertTabletsReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("insertTablets", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.insertTabletsArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.insertTabletsResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "insertTablets failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> insertRecordsAsync(TSInsertRecordsReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("insertRecords", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.insertRecordsArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.insertRecordsResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "insertRecords failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> insertRecordsOfOneDeviceAsync(TSInsertRecordsOfOneDeviceReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("insertRecordsOfOneDevice", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.insertRecordsOfOneDeviceArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.insertRecordsOfOneDeviceResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "insertRecordsOfOneDevice failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> insertStringRecordsOfOneDeviceAsync(TSInsertStringRecordsOfOneDeviceReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("insertStringRecordsOfOneDevice", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.insertStringRecordsOfOneDeviceArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.insertStringRecordsOfOneDeviceResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "insertStringRecordsOfOneDevice failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> insertStringRecordsAsync(TSInsertStringRecordsReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("insertStringRecords", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.insertStringRecordsArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.insertStringRecordsResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "insertStringRecords failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> testInsertTabletAsync(TSInsertTabletReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("testInsertTablet", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.testInsertTabletArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.testInsertTabletResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "testInsertTablet failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> testInsertTabletsAsync(TSInsertTabletsReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("testInsertTablets", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.testInsertTabletsArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.testInsertTabletsResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "testInsertTablets failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> testInsertRecordAsync(TSInsertRecordReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("testInsertRecord", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.testInsertRecordArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.testInsertRecordResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "testInsertRecord failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> testInsertStringRecordAsync(TSInsertStringRecordReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("testInsertStringRecord", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.testInsertStringRecordArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.testInsertStringRecordResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "testInsertStringRecord failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> testInsertRecordsAsync(TSInsertRecordsReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("testInsertRecords", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.testInsertRecordsArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.testInsertRecordsResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "testInsertRecords failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> testInsertRecordsOfOneDeviceAsync(TSInsertRecordsOfOneDeviceReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("testInsertRecordsOfOneDevice", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.testInsertRecordsOfOneDeviceArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.testInsertRecordsOfOneDeviceResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "testInsertRecordsOfOneDevice failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> testInsertStringRecordsAsync(TSInsertStringRecordsReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("testInsertStringRecords", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.testInsertStringRecordsArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.testInsertStringRecordsResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "testInsertStringRecords failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> deleteDataAsync(TSDeleteDataReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("deleteData", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.deleteDataArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.deleteDataResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "deleteData failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeRawDataQueryAsync(TSRawDataQueryReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeRawDataQuery", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeRawDataQueryArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeRawDataQueryResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeRawDataQuery failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeLastDataQueryAsync(TSLastDataQueryReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeLastDataQuery", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeLastDataQueryArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeLastDataQueryResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeLastDataQuery failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSExecuteStatementResp> executeAggregationQueryAsync(TSAggregationQueryReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("executeAggregationQuery", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.executeAggregationQueryArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.executeAggregationQueryResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "executeAggregationQuery failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<long> requestStatementIdAsync(long sessionId, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("requestStatementId", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.requestStatementIdArgs() {
        SessionId = sessionId,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.requestStatementIdResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "requestStatementId failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> createSchemaTemplateAsync(TSCreateSchemaTemplateReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("createSchemaTemplate", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.createSchemaTemplateArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.createSchemaTemplateResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "createSchemaTemplate failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> appendSchemaTemplateAsync(TSAppendSchemaTemplateReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("appendSchemaTemplate", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.appendSchemaTemplateArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.appendSchemaTemplateResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "appendSchemaTemplate failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> pruneSchemaTemplateAsync(TSPruneSchemaTemplateReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("pruneSchemaTemplate", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.pruneSchemaTemplateArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.pruneSchemaTemplateResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "pruneSchemaTemplate failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSQueryTemplateResp> querySchemaTemplateAsync(TSQueryTemplateReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("querySchemaTemplate", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.querySchemaTemplateArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.querySchemaTemplateResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "querySchemaTemplate failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TShowConfigurationTemplateResp> showConfigurationTemplateAsync(CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("showConfigurationTemplate", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.showConfigurationTemplateArgs() {
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.showConfigurationTemplateResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "showConfigurationTemplate failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TShowConfigurationResp> showConfigurationAsync(int nodeId, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("showConfiguration", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.showConfigurationArgs() {
        NodeId = nodeId,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.showConfigurationResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "showConfiguration failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> setSchemaTemplateAsync(TSSetSchemaTemplateReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("setSchemaTemplate", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.setSchemaTemplateArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.setSchemaTemplateResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "setSchemaTemplate failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> unsetSchemaTemplateAsync(TSUnsetSchemaTemplateReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("unsetSchemaTemplate", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.unsetSchemaTemplateArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.unsetSchemaTemplateResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "unsetSchemaTemplate failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> dropSchemaTemplateAsync(TSDropSchemaTemplateReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("dropSchemaTemplate", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.dropSchemaTemplateArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.dropSchemaTemplateResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "dropSchemaTemplate failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> createTimeseriesUsingSchemaTemplateAsync(TCreateTimeseriesUsingSchemaTemplateReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("createTimeseriesUsingSchemaTemplate", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.createTimeseriesUsingSchemaTemplateArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.createTimeseriesUsingSchemaTemplateResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "createTimeseriesUsingSchemaTemplate failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> handshakeAsync(TSyncIdentityInfo info, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("handshake", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.handshakeArgs() {
        Info = info,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.handshakeResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "handshake failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> sendPipeDataAsync(byte[] buff, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("sendPipeData", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.sendPipeDataArgs() {
        Buff = buff,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.sendPipeDataResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "sendPipeData failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> sendFileAsync(TSyncTransportMetaInfo metaInfo, byte[] buff, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("sendFile", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.sendFileArgs() {
        MetaInfo = metaInfo,
        Buff = buff,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.sendFileResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "sendFile failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TPipeTransferResp> pipeTransferAsync(TPipeTransferReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("pipeTransfer", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.pipeTransferArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.pipeTransferResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "pipeTransfer failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TPipeSubscribeResp> pipeSubscribeAsync(TPipeSubscribeReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("pipeSubscribe", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.pipeSubscribeArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.pipeSubscribeResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "pipeSubscribe failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSBackupConfigurationResp> getBackupConfigurationAsync(CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("getBackupConfiguration", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.getBackupConfigurationArgs() {
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.getBackupConfigurationResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getBackupConfiguration failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSConnectionInfoResp> fetchAllConnectionsInfoAsync(CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("fetchAllConnectionsInfo", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.fetchAllConnectionsInfoArgs() {
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.fetchAllConnectionsInfoResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "fetchAllConnectionsInfo failed: unknown result");
    }

    public async global::System.Threading.Tasks.Task<TSStatus> testConnectionEmptyRPCAsync(CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("testConnectionEmptyRPC", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.testConnectionEmptyRPCArgs() {
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

      var result = new InternalStructs.testConnectionEmptyRPCResult();
      await result.ReadAsync(InputProtocol, cancellationToken);
      await InputProtocol.ReadMessageEndAsync(cancellationToken);
      if (result.__isset.success)
      {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "testConnectionEmptyRPC failed: unknown result");
    }

  }

  public class AsyncProcessor : ITAsyncProcessor
  {
    private readonly IAsync _iAsync;
    private readonly ILogger<AsyncProcessor> _logger;

    public AsyncProcessor(IAsync iAsync, ILogger<AsyncProcessor> logger = default)
    {
      _iAsync = iAsync ?? throw new ArgumentNullException(nameof(iAsync));
      _logger = logger;
      processMap_["executeQueryStatementV2"] = executeQueryStatementV2_ProcessAsync;
      processMap_["executeUpdateStatementV2"] = executeUpdateStatementV2_ProcessAsync;
      processMap_["executeStatementV2"] = executeStatementV2_ProcessAsync;
      processMap_["executeRawDataQueryV2"] = executeRawDataQueryV2_ProcessAsync;
      processMap_["executeLastDataQueryV2"] = executeLastDataQueryV2_ProcessAsync;
      processMap_["executeFastLastDataQueryForOneDeviceV2"] = executeFastLastDataQueryForOneDeviceV2_ProcessAsync;
      processMap_["executeAggregationQueryV2"] = executeAggregationQueryV2_ProcessAsync;
      processMap_["executeGroupByQueryIntervalQuery"] = executeGroupByQueryIntervalQuery_ProcessAsync;
      processMap_["fetchResultsV2"] = fetchResultsV2_ProcessAsync;
      processMap_["openSession"] = openSession_ProcessAsync;
      processMap_["closeSession"] = closeSession_ProcessAsync;
      processMap_["executeStatement"] = executeStatement_ProcessAsync;
      processMap_["executeBatchStatement"] = executeBatchStatement_ProcessAsync;
      processMap_["executeQueryStatement"] = executeQueryStatement_ProcessAsync;
      processMap_["executeUpdateStatement"] = executeUpdateStatement_ProcessAsync;
      processMap_["fetchResults"] = fetchResults_ProcessAsync;
      processMap_["fetchMetadata"] = fetchMetadata_ProcessAsync;
      processMap_["cancelOperation"] = cancelOperation_ProcessAsync;
      processMap_["closeOperation"] = closeOperation_ProcessAsync;
      processMap_["getTimeZone"] = getTimeZone_ProcessAsync;
      processMap_["setTimeZone"] = setTimeZone_ProcessAsync;
      processMap_["getProperties"] = getProperties_ProcessAsync;
      processMap_["setStorageGroup"] = setStorageGroup_ProcessAsync;
      processMap_["createTimeseries"] = createTimeseries_ProcessAsync;
      processMap_["createAlignedTimeseries"] = createAlignedTimeseries_ProcessAsync;
      processMap_["createMultiTimeseries"] = createMultiTimeseries_ProcessAsync;
      processMap_["deleteTimeseries"] = deleteTimeseries_ProcessAsync;
      processMap_["deleteStorageGroups"] = deleteStorageGroups_ProcessAsync;
      processMap_["insertRecord"] = insertRecord_ProcessAsync;
      processMap_["insertStringRecord"] = insertStringRecord_ProcessAsync;
      processMap_["insertTablet"] = insertTablet_ProcessAsync;
      processMap_["insertTablets"] = insertTablets_ProcessAsync;
      processMap_["insertRecords"] = insertRecords_ProcessAsync;
      processMap_["insertRecordsOfOneDevice"] = insertRecordsOfOneDevice_ProcessAsync;
      processMap_["insertStringRecordsOfOneDevice"] = insertStringRecordsOfOneDevice_ProcessAsync;
      processMap_["insertStringRecords"] = insertStringRecords_ProcessAsync;
      processMap_["testInsertTablet"] = testInsertTablet_ProcessAsync;
      processMap_["testInsertTablets"] = testInsertTablets_ProcessAsync;
      processMap_["testInsertRecord"] = testInsertRecord_ProcessAsync;
      processMap_["testInsertStringRecord"] = testInsertStringRecord_ProcessAsync;
      processMap_["testInsertRecords"] = testInsertRecords_ProcessAsync;
      processMap_["testInsertRecordsOfOneDevice"] = testInsertRecordsOfOneDevice_ProcessAsync;
      processMap_["testInsertStringRecords"] = testInsertStringRecords_ProcessAsync;
      processMap_["deleteData"] = deleteData_ProcessAsync;
      processMap_["executeRawDataQuery"] = executeRawDataQuery_ProcessAsync;
      processMap_["executeLastDataQuery"] = executeLastDataQuery_ProcessAsync;
      processMap_["executeAggregationQuery"] = executeAggregationQuery_ProcessAsync;
      processMap_["requestStatementId"] = requestStatementId_ProcessAsync;
      processMap_["createSchemaTemplate"] = createSchemaTemplate_ProcessAsync;
      processMap_["appendSchemaTemplate"] = appendSchemaTemplate_ProcessAsync;
      processMap_["pruneSchemaTemplate"] = pruneSchemaTemplate_ProcessAsync;
      processMap_["querySchemaTemplate"] = querySchemaTemplate_ProcessAsync;
      processMap_["showConfigurationTemplate"] = showConfigurationTemplate_ProcessAsync;
      processMap_["showConfiguration"] = showConfiguration_ProcessAsync;
      processMap_["setSchemaTemplate"] = setSchemaTemplate_ProcessAsync;
      processMap_["unsetSchemaTemplate"] = unsetSchemaTemplate_ProcessAsync;
      processMap_["dropSchemaTemplate"] = dropSchemaTemplate_ProcessAsync;
      processMap_["createTimeseriesUsingSchemaTemplate"] = createTimeseriesUsingSchemaTemplate_ProcessAsync;
      processMap_["handshake"] = handshake_ProcessAsync;
      processMap_["sendPipeData"] = sendPipeData_ProcessAsync;
      processMap_["sendFile"] = sendFile_ProcessAsync;
      processMap_["pipeTransfer"] = pipeTransfer_ProcessAsync;
      processMap_["pipeSubscribe"] = pipeSubscribe_ProcessAsync;
      processMap_["getBackupConfiguration"] = getBackupConfiguration_ProcessAsync;
      processMap_["fetchAllConnectionsInfo"] = fetchAllConnectionsInfo_ProcessAsync;
      processMap_["testConnectionEmptyRPC"] = testConnectionEmptyRPC_ProcessAsync;
    }

    protected delegate global::System.Threading.Tasks.Task ProcessFunction(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken);
    protected Dictionary<string, ProcessFunction> processMap_ = new Dictionary<string, ProcessFunction>();

    public async Task<bool> ProcessAsync(TProtocol iprot, TProtocol oprot)
    {
      return await ProcessAsync(iprot, oprot, CancellationToken.None);
    }

    public async Task<bool> ProcessAsync(TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      try
      {
        var msg = await iprot.ReadMessageBeginAsync(cancellationToken);

        processMap_.TryGetValue(msg.Name, out ProcessFunction fn);

        if (fn == null)
        {
          await TProtocolUtil.SkipAsync(iprot, TType.Struct, cancellationToken);
          await iprot.ReadMessageEndAsync(cancellationToken);
          var x = new TApplicationException (TApplicationException.ExceptionType.UnknownMethod, "Invalid method name: '" + msg.Name + "'");
          await oprot.WriteMessageBeginAsync(new TMessage(msg.Name, TMessageType.Exception, msg.SeqID), cancellationToken);
          await x.WriteAsync(oprot, cancellationToken);
          await oprot.WriteMessageEndAsync(cancellationToken);
          await oprot.Transport.FlushAsync(cancellationToken);
          return true;
        }

        await fn(msg.SeqID, iprot, oprot, cancellationToken);

      }
      catch (IOException)
      {
        return false;
      }

      return true;
    }

    public async global::System.Threading.Tasks.Task executeQueryStatementV2_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeQueryStatementV2Args();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeQueryStatementV2Result();
      try
      {
        result.Success = await _iAsync.executeQueryStatementV2Async(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeQueryStatementV2", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeQueryStatementV2", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeUpdateStatementV2_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeUpdateStatementV2Args();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeUpdateStatementV2Result();
      try
      {
        result.Success = await _iAsync.executeUpdateStatementV2Async(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeUpdateStatementV2", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeUpdateStatementV2", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeStatementV2_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeStatementV2Args();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeStatementV2Result();
      try
      {
        result.Success = await _iAsync.executeStatementV2Async(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeStatementV2", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeStatementV2", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeRawDataQueryV2_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeRawDataQueryV2Args();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeRawDataQueryV2Result();
      try
      {
        result.Success = await _iAsync.executeRawDataQueryV2Async(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeRawDataQueryV2", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeRawDataQueryV2", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeLastDataQueryV2_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeLastDataQueryV2Args();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeLastDataQueryV2Result();
      try
      {
        result.Success = await _iAsync.executeLastDataQueryV2Async(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeLastDataQueryV2", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeLastDataQueryV2", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeFastLastDataQueryForOneDeviceV2_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeFastLastDataQueryForOneDeviceV2Args();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeFastLastDataQueryForOneDeviceV2Result();
      try
      {
        result.Success = await _iAsync.executeFastLastDataQueryForOneDeviceV2Async(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeFastLastDataQueryForOneDeviceV2", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeFastLastDataQueryForOneDeviceV2", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeAggregationQueryV2_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeAggregationQueryV2Args();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeAggregationQueryV2Result();
      try
      {
        result.Success = await _iAsync.executeAggregationQueryV2Async(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeAggregationQueryV2", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeAggregationQueryV2", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeGroupByQueryIntervalQuery_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeGroupByQueryIntervalQueryArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeGroupByQueryIntervalQueryResult();
      try
      {
        result.Success = await _iAsync.executeGroupByQueryIntervalQueryAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeGroupByQueryIntervalQuery", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeGroupByQueryIntervalQuery", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task fetchResultsV2_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.fetchResultsV2Args();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.fetchResultsV2Result();
      try
      {
        result.Success = await _iAsync.fetchResultsV2Async(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("fetchResultsV2", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("fetchResultsV2", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task openSession_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.openSessionArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.openSessionResult();
      try
      {
        result.Success = await _iAsync.openSessionAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("openSession", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("openSession", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task closeSession_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.closeSessionArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.closeSessionResult();
      try
      {
        result.Success = await _iAsync.closeSessionAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("closeSession", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("closeSession", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeStatement_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeStatementArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeStatementResult();
      try
      {
        result.Success = await _iAsync.executeStatementAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeStatement", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeStatement", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeBatchStatement_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeBatchStatementArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeBatchStatementResult();
      try
      {
        result.Success = await _iAsync.executeBatchStatementAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeBatchStatement", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeBatchStatement", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeQueryStatement_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeQueryStatementArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeQueryStatementResult();
      try
      {
        result.Success = await _iAsync.executeQueryStatementAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeQueryStatement", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeQueryStatement", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeUpdateStatement_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeUpdateStatementArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeUpdateStatementResult();
      try
      {
        result.Success = await _iAsync.executeUpdateStatementAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeUpdateStatement", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeUpdateStatement", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task fetchResults_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.fetchResultsArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.fetchResultsResult();
      try
      {
        result.Success = await _iAsync.fetchResultsAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("fetchResults", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("fetchResults", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task fetchMetadata_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.fetchMetadataArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.fetchMetadataResult();
      try
      {
        result.Success = await _iAsync.fetchMetadataAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("fetchMetadata", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("fetchMetadata", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task cancelOperation_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.cancelOperationArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.cancelOperationResult();
      try
      {
        result.Success = await _iAsync.cancelOperationAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("cancelOperation", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("cancelOperation", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task closeOperation_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.closeOperationArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.closeOperationResult();
      try
      {
        result.Success = await _iAsync.closeOperationAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("closeOperation", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("closeOperation", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task getTimeZone_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.getTimeZoneArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.getTimeZoneResult();
      try
      {
        result.Success = await _iAsync.getTimeZoneAsync(args.SessionId, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("getTimeZone", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("getTimeZone", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task setTimeZone_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.setTimeZoneArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.setTimeZoneResult();
      try
      {
        result.Success = await _iAsync.setTimeZoneAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("setTimeZone", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("setTimeZone", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task getProperties_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.getPropertiesArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.getPropertiesResult();
      try
      {
        result.Success = await _iAsync.getPropertiesAsync(cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("getProperties", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("getProperties", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task setStorageGroup_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.setStorageGroupArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.setStorageGroupResult();
      try
      {
        result.Success = await _iAsync.setStorageGroupAsync(args.SessionId, args.StorageGroup, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("setStorageGroup", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("setStorageGroup", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task createTimeseries_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.createTimeseriesArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.createTimeseriesResult();
      try
      {
        result.Success = await _iAsync.createTimeseriesAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("createTimeseries", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("createTimeseries", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task createAlignedTimeseries_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.createAlignedTimeseriesArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.createAlignedTimeseriesResult();
      try
      {
        result.Success = await _iAsync.createAlignedTimeseriesAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("createAlignedTimeseries", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("createAlignedTimeseries", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task createMultiTimeseries_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.createMultiTimeseriesArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.createMultiTimeseriesResult();
      try
      {
        result.Success = await _iAsync.createMultiTimeseriesAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("createMultiTimeseries", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("createMultiTimeseries", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task deleteTimeseries_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.deleteTimeseriesArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.deleteTimeseriesResult();
      try
      {
        result.Success = await _iAsync.deleteTimeseriesAsync(args.SessionId, args.Path, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("deleteTimeseries", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("deleteTimeseries", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task deleteStorageGroups_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.deleteStorageGroupsArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.deleteStorageGroupsResult();
      try
      {
        result.Success = await _iAsync.deleteStorageGroupsAsync(args.SessionId, args.StorageGroup, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("deleteStorageGroups", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("deleteStorageGroups", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task insertRecord_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.insertRecordArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.insertRecordResult();
      try
      {
        result.Success = await _iAsync.insertRecordAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("insertRecord", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("insertRecord", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task insertStringRecord_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.insertStringRecordArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.insertStringRecordResult();
      try
      {
        result.Success = await _iAsync.insertStringRecordAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("insertStringRecord", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("insertStringRecord", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task insertTablet_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.insertTabletArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.insertTabletResult();
      try
      {
        result.Success = await _iAsync.insertTabletAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("insertTablet", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("insertTablet", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task insertTablets_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.insertTabletsArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.insertTabletsResult();
      try
      {
        result.Success = await _iAsync.insertTabletsAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("insertTablets", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("insertTablets", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task insertRecords_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.insertRecordsArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.insertRecordsResult();
      try
      {
        result.Success = await _iAsync.insertRecordsAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("insertRecords", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("insertRecords", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task insertRecordsOfOneDevice_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.insertRecordsOfOneDeviceArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.insertRecordsOfOneDeviceResult();
      try
      {
        result.Success = await _iAsync.insertRecordsOfOneDeviceAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("insertRecordsOfOneDevice", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("insertRecordsOfOneDevice", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task insertStringRecordsOfOneDevice_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.insertStringRecordsOfOneDeviceArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.insertStringRecordsOfOneDeviceResult();
      try
      {
        result.Success = await _iAsync.insertStringRecordsOfOneDeviceAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("insertStringRecordsOfOneDevice", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("insertStringRecordsOfOneDevice", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task insertStringRecords_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.insertStringRecordsArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.insertStringRecordsResult();
      try
      {
        result.Success = await _iAsync.insertStringRecordsAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("insertStringRecords", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("insertStringRecords", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task testInsertTablet_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.testInsertTabletArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.testInsertTabletResult();
      try
      {
        result.Success = await _iAsync.testInsertTabletAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertTablet", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertTablet", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task testInsertTablets_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.testInsertTabletsArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.testInsertTabletsResult();
      try
      {
        result.Success = await _iAsync.testInsertTabletsAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertTablets", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertTablets", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task testInsertRecord_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.testInsertRecordArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.testInsertRecordResult();
      try
      {
        result.Success = await _iAsync.testInsertRecordAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertRecord", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertRecord", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task testInsertStringRecord_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.testInsertStringRecordArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.testInsertStringRecordResult();
      try
      {
        result.Success = await _iAsync.testInsertStringRecordAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertStringRecord", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertStringRecord", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task testInsertRecords_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.testInsertRecordsArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.testInsertRecordsResult();
      try
      {
        result.Success = await _iAsync.testInsertRecordsAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertRecords", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertRecords", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task testInsertRecordsOfOneDevice_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.testInsertRecordsOfOneDeviceArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.testInsertRecordsOfOneDeviceResult();
      try
      {
        result.Success = await _iAsync.testInsertRecordsOfOneDeviceAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertRecordsOfOneDevice", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertRecordsOfOneDevice", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task testInsertStringRecords_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.testInsertStringRecordsArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.testInsertStringRecordsResult();
      try
      {
        result.Success = await _iAsync.testInsertStringRecordsAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertStringRecords", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("testInsertStringRecords", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task deleteData_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.deleteDataArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.deleteDataResult();
      try
      {
        result.Success = await _iAsync.deleteDataAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("deleteData", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("deleteData", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeRawDataQuery_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeRawDataQueryArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeRawDataQueryResult();
      try
      {
        result.Success = await _iAsync.executeRawDataQueryAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeRawDataQuery", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeRawDataQuery", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeLastDataQuery_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeLastDataQueryArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeLastDataQueryResult();
      try
      {
        result.Success = await _iAsync.executeLastDataQueryAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeLastDataQuery", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeLastDataQuery", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task executeAggregationQuery_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.executeAggregationQueryArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.executeAggregationQueryResult();
      try
      {
        result.Success = await _iAsync.executeAggregationQueryAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("executeAggregationQuery", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("executeAggregationQuery", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task requestStatementId_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.requestStatementIdArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.requestStatementIdResult();
      try
      {
        result.Success = await _iAsync.requestStatementIdAsync(args.SessionId, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("requestStatementId", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("requestStatementId", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task createSchemaTemplate_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.createSchemaTemplateArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.createSchemaTemplateResult();
      try
      {
        result.Success = await _iAsync.createSchemaTemplateAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("createSchemaTemplate", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("createSchemaTemplate", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task appendSchemaTemplate_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.appendSchemaTemplateArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.appendSchemaTemplateResult();
      try
      {
        result.Success = await _iAsync.appendSchemaTemplateAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("appendSchemaTemplate", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("appendSchemaTemplate", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task pruneSchemaTemplate_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.pruneSchemaTemplateArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.pruneSchemaTemplateResult();
      try
      {
        result.Success = await _iAsync.pruneSchemaTemplateAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("pruneSchemaTemplate", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("pruneSchemaTemplate", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task querySchemaTemplate_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.querySchemaTemplateArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.querySchemaTemplateResult();
      try
      {
        result.Success = await _iAsync.querySchemaTemplateAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("querySchemaTemplate", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("querySchemaTemplate", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task showConfigurationTemplate_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.showConfigurationTemplateArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.showConfigurationTemplateResult();
      try
      {
        result.Success = await _iAsync.showConfigurationTemplateAsync(cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("showConfigurationTemplate", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("showConfigurationTemplate", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task showConfiguration_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.showConfigurationArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.showConfigurationResult();
      try
      {
        result.Success = await _iAsync.showConfigurationAsync(args.NodeId, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("showConfiguration", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("showConfiguration", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task setSchemaTemplate_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.setSchemaTemplateArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.setSchemaTemplateResult();
      try
      {
        result.Success = await _iAsync.setSchemaTemplateAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("setSchemaTemplate", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("setSchemaTemplate", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task unsetSchemaTemplate_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.unsetSchemaTemplateArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.unsetSchemaTemplateResult();
      try
      {
        result.Success = await _iAsync.unsetSchemaTemplateAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("unsetSchemaTemplate", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("unsetSchemaTemplate", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task dropSchemaTemplate_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.dropSchemaTemplateArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.dropSchemaTemplateResult();
      try
      {
        result.Success = await _iAsync.dropSchemaTemplateAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("dropSchemaTemplate", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("dropSchemaTemplate", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task createTimeseriesUsingSchemaTemplate_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.createTimeseriesUsingSchemaTemplateArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.createTimeseriesUsingSchemaTemplateResult();
      try
      {
        result.Success = await _iAsync.createTimeseriesUsingSchemaTemplateAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("createTimeseriesUsingSchemaTemplate", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("createTimeseriesUsingSchemaTemplate", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task handshake_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.handshakeArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.handshakeResult();
      try
      {
        result.Success = await _iAsync.handshakeAsync(args.Info, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("handshake", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("handshake", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task sendPipeData_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.sendPipeDataArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.sendPipeDataResult();
      try
      {
        result.Success = await _iAsync.sendPipeDataAsync(args.Buff, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("sendPipeData", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("sendPipeData", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task sendFile_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.sendFileArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.sendFileResult();
      try
      {
        result.Success = await _iAsync.sendFileAsync(args.MetaInfo, args.Buff, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("sendFile", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("sendFile", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task pipeTransfer_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.pipeTransferArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.pipeTransferResult();
      try
      {
        result.Success = await _iAsync.pipeTransferAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("pipeTransfer", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("pipeTransfer", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task pipeSubscribe_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.pipeSubscribeArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.pipeSubscribeResult();
      try
      {
        result.Success = await _iAsync.pipeSubscribeAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("pipeSubscribe", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("pipeSubscribe", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task getBackupConfiguration_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.getBackupConfigurationArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.getBackupConfigurationResult();
      try
      {
        result.Success = await _iAsync.getBackupConfigurationAsync(cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("getBackupConfiguration", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("getBackupConfiguration", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task fetchAllConnectionsInfo_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.fetchAllConnectionsInfoArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.fetchAllConnectionsInfoResult();
      try
      {
        result.Success = await _iAsync.fetchAllConnectionsInfoAsync(cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("fetchAllConnectionsInfo", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("fetchAllConnectionsInfo", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

    public async global::System.Threading.Tasks.Task testConnectionEmptyRPC_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.testConnectionEmptyRPCArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.testConnectionEmptyRPCResult();
      try
      {
        result.Success = await _iAsync.testConnectionEmptyRPCAsync(cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("testConnectionEmptyRPC", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("testConnectionEmptyRPC", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

  }

  public class InternalStructs
  {

    public partial class executeQueryStatementV2Args : TBase
    {
      private TSExecuteStatementReq _req;

      public TSExecuteStatementReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeQueryStatementV2Args()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSExecuteStatementReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeQueryStatementV2_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeQueryStatementV2Args other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeQueryStatementV2_args(");
        int tmp417 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp417++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeQueryStatementV2Result : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeQueryStatementV2Result()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeQueryStatementV2_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeQueryStatementV2Result other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeQueryStatementV2_result(");
        int tmp418 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp418++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeUpdateStatementV2Args : TBase
    {
      private TSExecuteStatementReq _req;

      public TSExecuteStatementReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeUpdateStatementV2Args()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSExecuteStatementReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeUpdateStatementV2_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeUpdateStatementV2Args other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeUpdateStatementV2_args(");
        int tmp419 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp419++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeUpdateStatementV2Result : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeUpdateStatementV2Result()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeUpdateStatementV2_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeUpdateStatementV2Result other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeUpdateStatementV2_result(");
        int tmp420 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp420++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeStatementV2Args : TBase
    {
      private TSExecuteStatementReq _req;

      public TSExecuteStatementReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeStatementV2Args()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSExecuteStatementReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeStatementV2_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeStatementV2Args other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeStatementV2_args(");
        int tmp421 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp421++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeStatementV2Result : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeStatementV2Result()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeStatementV2_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeStatementV2Result other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeStatementV2_result(");
        int tmp422 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp422++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeRawDataQueryV2Args : TBase
    {
      private TSRawDataQueryReq _req;

      public TSRawDataQueryReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeRawDataQueryV2Args()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSRawDataQueryReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeRawDataQueryV2_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeRawDataQueryV2Args other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeRawDataQueryV2_args(");
        int tmp423 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp423++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeRawDataQueryV2Result : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeRawDataQueryV2Result()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeRawDataQueryV2_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeRawDataQueryV2Result other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeRawDataQueryV2_result(");
        int tmp424 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp424++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeLastDataQueryV2Args : TBase
    {
      private TSLastDataQueryReq _req;

      public TSLastDataQueryReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeLastDataQueryV2Args()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSLastDataQueryReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeLastDataQueryV2_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeLastDataQueryV2Args other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeLastDataQueryV2_args(");
        int tmp425 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp425++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeLastDataQueryV2Result : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeLastDataQueryV2Result()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeLastDataQueryV2_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeLastDataQueryV2Result other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeLastDataQueryV2_result(");
        int tmp426 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp426++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeFastLastDataQueryForOneDeviceV2Args : TBase
    {
      private TSFastLastDataQueryForOneDeviceReq _req;

      public TSFastLastDataQueryForOneDeviceReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeFastLastDataQueryForOneDeviceV2Args()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSFastLastDataQueryForOneDeviceReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeFastLastDataQueryForOneDeviceV2_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeFastLastDataQueryForOneDeviceV2Args other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeFastLastDataQueryForOneDeviceV2_args(");
        int tmp427 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp427++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeFastLastDataQueryForOneDeviceV2Result : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeFastLastDataQueryForOneDeviceV2Result()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeFastLastDataQueryForOneDeviceV2_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeFastLastDataQueryForOneDeviceV2Result other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeFastLastDataQueryForOneDeviceV2_result(");
        int tmp428 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp428++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeAggregationQueryV2Args : TBase
    {
      private TSAggregationQueryReq _req;

      public TSAggregationQueryReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeAggregationQueryV2Args()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSAggregationQueryReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeAggregationQueryV2_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeAggregationQueryV2Args other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeAggregationQueryV2_args(");
        int tmp429 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp429++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeAggregationQueryV2Result : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeAggregationQueryV2Result()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeAggregationQueryV2_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeAggregationQueryV2Result other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeAggregationQueryV2_result(");
        int tmp430 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp430++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeGroupByQueryIntervalQueryArgs : TBase
    {
      private TSGroupByQueryIntervalReq _req;

      public TSGroupByQueryIntervalReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeGroupByQueryIntervalQueryArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSGroupByQueryIntervalReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeGroupByQueryIntervalQuery_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeGroupByQueryIntervalQueryArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeGroupByQueryIntervalQuery_args(");
        int tmp431 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp431++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeGroupByQueryIntervalQueryResult : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeGroupByQueryIntervalQueryResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeGroupByQueryIntervalQuery_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeGroupByQueryIntervalQueryResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeGroupByQueryIntervalQuery_result(");
        int tmp432 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp432++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class fetchResultsV2Args : TBase
    {
      private TSFetchResultsReq _req;

      public TSFetchResultsReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public fetchResultsV2Args()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSFetchResultsReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("fetchResultsV2_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is fetchResultsV2Args other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("fetchResultsV2_args(");
        int tmp433 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp433++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class fetchResultsV2Result : TBase
    {
      private TSFetchResultsResp _success;

      public TSFetchResultsResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public fetchResultsV2Result()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSFetchResultsResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("fetchResultsV2_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is fetchResultsV2Result other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("fetchResultsV2_result(");
        int tmp434 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp434++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class openSessionArgs : TBase
    {
      private TSOpenSessionReq _req;

      public TSOpenSessionReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public openSessionArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSOpenSessionReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("openSession_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is openSessionArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("openSession_args(");
        int tmp435 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp435++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class openSessionResult : TBase
    {
      private TSOpenSessionResp _success;

      public TSOpenSessionResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public openSessionResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSOpenSessionResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("openSession_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is openSessionResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("openSession_result(");
        int tmp436 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp436++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class closeSessionArgs : TBase
    {
      private TSCloseSessionReq _req;

      public TSCloseSessionReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public closeSessionArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSCloseSessionReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("closeSession_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is closeSessionArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("closeSession_args(");
        int tmp437 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp437++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class closeSessionResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public closeSessionResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("closeSession_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is closeSessionResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("closeSession_result(");
        int tmp438 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp438++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeStatementArgs : TBase
    {
      private TSExecuteStatementReq _req;

      public TSExecuteStatementReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeStatementArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSExecuteStatementReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeStatement_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeStatementArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeStatement_args(");
        int tmp439 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp439++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeStatementResult : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeStatementResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeStatement_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeStatementResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeStatement_result(");
        int tmp440 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp440++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeBatchStatementArgs : TBase
    {
      private TSExecuteBatchStatementReq _req;

      public TSExecuteBatchStatementReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeBatchStatementArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSExecuteBatchStatementReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeBatchStatement_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeBatchStatementArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeBatchStatement_args(");
        int tmp441 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp441++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeBatchStatementResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeBatchStatementResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeBatchStatement_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeBatchStatementResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeBatchStatement_result(");
        int tmp442 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp442++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeQueryStatementArgs : TBase
    {
      private TSExecuteStatementReq _req;

      public TSExecuteStatementReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeQueryStatementArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSExecuteStatementReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeQueryStatement_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeQueryStatementArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeQueryStatement_args(");
        int tmp443 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp443++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeQueryStatementResult : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeQueryStatementResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeQueryStatement_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeQueryStatementResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeQueryStatement_result(");
        int tmp444 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp444++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeUpdateStatementArgs : TBase
    {
      private TSExecuteStatementReq _req;

      public TSExecuteStatementReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeUpdateStatementArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSExecuteStatementReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeUpdateStatement_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeUpdateStatementArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeUpdateStatement_args(");
        int tmp445 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp445++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeUpdateStatementResult : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeUpdateStatementResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeUpdateStatement_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeUpdateStatementResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeUpdateStatement_result(");
        int tmp446 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp446++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class fetchResultsArgs : TBase
    {
      private TSFetchResultsReq _req;

      public TSFetchResultsReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public fetchResultsArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSFetchResultsReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("fetchResults_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is fetchResultsArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("fetchResults_args(");
        int tmp447 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp447++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class fetchResultsResult : TBase
    {
      private TSFetchResultsResp _success;

      public TSFetchResultsResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public fetchResultsResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSFetchResultsResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("fetchResults_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is fetchResultsResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("fetchResults_result(");
        int tmp448 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp448++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class fetchMetadataArgs : TBase
    {
      private TSFetchMetadataReq _req;

      public TSFetchMetadataReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public fetchMetadataArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSFetchMetadataReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("fetchMetadata_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is fetchMetadataArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("fetchMetadata_args(");
        int tmp449 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp449++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class fetchMetadataResult : TBase
    {
      private TSFetchMetadataResp _success;

      public TSFetchMetadataResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public fetchMetadataResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSFetchMetadataResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("fetchMetadata_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is fetchMetadataResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("fetchMetadata_result(");
        int tmp450 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp450++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class cancelOperationArgs : TBase
    {
      private TSCancelOperationReq _req;

      public TSCancelOperationReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public cancelOperationArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSCancelOperationReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("cancelOperation_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is cancelOperationArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("cancelOperation_args(");
        int tmp451 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp451++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class cancelOperationResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public cancelOperationResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("cancelOperation_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is cancelOperationResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("cancelOperation_result(");
        int tmp452 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp452++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class closeOperationArgs : TBase
    {
      private TSCloseOperationReq _req;

      public TSCloseOperationReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public closeOperationArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSCloseOperationReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("closeOperation_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is closeOperationArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("closeOperation_args(");
        int tmp453 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp453++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class closeOperationResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public closeOperationResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("closeOperation_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is closeOperationResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("closeOperation_result(");
        int tmp454 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp454++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class getTimeZoneArgs : TBase
    {
      private long _sessionId;

      public long SessionId
      {
        get
        {
          return _sessionId;
        }
        set
        {
          __isset.sessionId = true;
          this._sessionId = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool sessionId;
      }

      public getTimeZoneArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.I64)
                {
                  SessionId = await iprot.ReadI64Async(cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("getTimeZone_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if(__isset.sessionId)
          {
            field.Name = "sessionId";
            field.Type = TType.I64;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI64Async(SessionId, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is getTimeZoneArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.sessionId == other.__isset.sessionId) && ((!__isset.sessionId) || (System.Object.Equals(SessionId, other.SessionId))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if(__isset.sessionId)
          {
            hashcode = (hashcode * 397) + SessionId.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("getTimeZone_args(");
        int tmp455 = 0;
        if(__isset.sessionId)
        {
          if(0 < tmp455++) { sb.Append(", "); }
          sb.Append("SessionId: ");
          SessionId.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class getTimeZoneResult : TBase
    {
      private TSGetTimeZoneResp _success;

      public TSGetTimeZoneResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public getTimeZoneResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSGetTimeZoneResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("getTimeZone_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is getTimeZoneResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("getTimeZone_result(");
        int tmp456 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp456++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class setTimeZoneArgs : TBase
    {
      private TSSetTimeZoneReq _req;

      public TSSetTimeZoneReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public setTimeZoneArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSSetTimeZoneReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("setTimeZone_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is setTimeZoneArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("setTimeZone_args(");
        int tmp457 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp457++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class setTimeZoneResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public setTimeZoneResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("setTimeZone_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is setTimeZoneResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("setTimeZone_result(");
        int tmp458 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp458++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class getPropertiesArgs : TBase
    {

      public getPropertiesArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("getProperties_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is getPropertiesArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return true;
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("getProperties_args(");
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class getPropertiesResult : TBase
    {
      private ServerProperties _success;

      public ServerProperties Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public getPropertiesResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new ServerProperties();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("getProperties_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is getPropertiesResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("getProperties_result(");
        int tmp460 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp460++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class setStorageGroupArgs : TBase
    {
      private long _sessionId;
      private string _storageGroup;

      public long SessionId
      {
        get
        {
          return _sessionId;
        }
        set
        {
          __isset.sessionId = true;
          this._sessionId = value;
        }
      }

      public string StorageGroup
      {
        get
        {
          return _storageGroup;
        }
        set
        {
          __isset.storageGroup = true;
          this._storageGroup = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool sessionId;
        public bool storageGroup;
      }

      public setStorageGroupArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.I64)
                {
                  SessionId = await iprot.ReadI64Async(cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              case 2:
                if (field.Type == TType.String)
                {
                  StorageGroup = await iprot.ReadStringAsync(cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("setStorageGroup_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if(__isset.sessionId)
          {
            field.Name = "sessionId";
            field.Type = TType.I64;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI64Async(SessionId, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          if((StorageGroup != null) && __isset.storageGroup)
          {
            field.Name = "storageGroup";
            field.Type = TType.String;
            field.ID = 2;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteStringAsync(StorageGroup, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is setStorageGroupArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.sessionId == other.__isset.sessionId) && ((!__isset.sessionId) || (System.Object.Equals(SessionId, other.SessionId))))
          && ((__isset.storageGroup == other.__isset.storageGroup) && ((!__isset.storageGroup) || (System.Object.Equals(StorageGroup, other.StorageGroup))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if(__isset.sessionId)
          {
            hashcode = (hashcode * 397) + SessionId.GetHashCode();
          }
          if((StorageGroup != null) && __isset.storageGroup)
          {
            hashcode = (hashcode * 397) + StorageGroup.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("setStorageGroup_args(");
        int tmp461 = 0;
        if(__isset.sessionId)
        {
          if(0 < tmp461++) { sb.Append(", "); }
          sb.Append("SessionId: ");
          SessionId.ToString(sb);
        }
        if((StorageGroup != null) && __isset.storageGroup)
        {
          if(0 < tmp461++) { sb.Append(", "); }
          sb.Append("StorageGroup: ");
          StorageGroup.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class setStorageGroupResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public setStorageGroupResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("setStorageGroup_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is setStorageGroupResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("setStorageGroup_result(");
        int tmp462 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp462++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class createTimeseriesArgs : TBase
    {
      private TSCreateTimeseriesReq _req;

      public TSCreateTimeseriesReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public createTimeseriesArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSCreateTimeseriesReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("createTimeseries_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is createTimeseriesArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("createTimeseries_args(");
        int tmp463 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp463++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class createTimeseriesResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public createTimeseriesResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("createTimeseries_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is createTimeseriesResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("createTimeseries_result(");
        int tmp464 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp464++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class createAlignedTimeseriesArgs : TBase
    {
      private TSCreateAlignedTimeseriesReq _req;

      public TSCreateAlignedTimeseriesReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public createAlignedTimeseriesArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSCreateAlignedTimeseriesReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("createAlignedTimeseries_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is createAlignedTimeseriesArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("createAlignedTimeseries_args(");
        int tmp465 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp465++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class createAlignedTimeseriesResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public createAlignedTimeseriesResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("createAlignedTimeseries_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is createAlignedTimeseriesResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("createAlignedTimeseries_result(");
        int tmp466 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp466++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class createMultiTimeseriesArgs : TBase
    {
      private TSCreateMultiTimeseriesReq _req;

      public TSCreateMultiTimeseriesReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public createMultiTimeseriesArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSCreateMultiTimeseriesReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("createMultiTimeseries_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is createMultiTimeseriesArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("createMultiTimeseries_args(");
        int tmp467 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp467++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class createMultiTimeseriesResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public createMultiTimeseriesResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("createMultiTimeseries_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is createMultiTimeseriesResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("createMultiTimeseries_result(");
        int tmp468 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp468++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class deleteTimeseriesArgs : TBase
    {
      private long _sessionId;
      private List<string> _path;

      public long SessionId
      {
        get
        {
          return _sessionId;
        }
        set
        {
          __isset.sessionId = true;
          this._sessionId = value;
        }
      }

      public List<string> Path
      {
        get
        {
          return _path;
        }
        set
        {
          __isset.path = true;
          this._path = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool sessionId;
        public bool path;
      }

      public deleteTimeseriesArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.I64)
                {
                  SessionId = await iprot.ReadI64Async(cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              case 2:
                if (field.Type == TType.List)
                {
                  {
                    TList _list469 = await iprot.ReadListBeginAsync(cancellationToken);
                    Path = new List<string>(_list469.Count);
                    for(int _i470 = 0; _i470 < _list469.Count; ++_i470)
                    {
                      string _elem471;
                      _elem471 = await iprot.ReadStringAsync(cancellationToken);
                      Path.Add(_elem471);
                    }
                    await iprot.ReadListEndAsync(cancellationToken);
                  }
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("deleteTimeseries_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if(__isset.sessionId)
          {
            field.Name = "sessionId";
            field.Type = TType.I64;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI64Async(SessionId, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          if((Path != null) && __isset.path)
          {
            field.Name = "path";
            field.Type = TType.List;
            field.ID = 2;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            {
              await oprot.WriteListBeginAsync(new TList(TType.String, Path.Count), cancellationToken);
              foreach (string _iter472 in Path)
              {
                await oprot.WriteStringAsync(_iter472, cancellationToken);
              }
              await oprot.WriteListEndAsync(cancellationToken);
            }
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is deleteTimeseriesArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.sessionId == other.__isset.sessionId) && ((!__isset.sessionId) || (System.Object.Equals(SessionId, other.SessionId))))
          && ((__isset.path == other.__isset.path) && ((!__isset.path) || (TCollections.Equals(Path, other.Path))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if(__isset.sessionId)
          {
            hashcode = (hashcode * 397) + SessionId.GetHashCode();
          }
          if((Path != null) && __isset.path)
          {
            hashcode = (hashcode * 397) + TCollections.GetHashCode(Path);
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("deleteTimeseries_args(");
        int tmp473 = 0;
        if(__isset.sessionId)
        {
          if(0 < tmp473++) { sb.Append(", "); }
          sb.Append("SessionId: ");
          SessionId.ToString(sb);
        }
        if((Path != null) && __isset.path)
        {
          if(0 < tmp473++) { sb.Append(", "); }
          sb.Append("Path: ");
          Path.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class deleteTimeseriesResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public deleteTimeseriesResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("deleteTimeseries_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is deleteTimeseriesResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("deleteTimeseries_result(");
        int tmp474 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp474++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class deleteStorageGroupsArgs : TBase
    {
      private long _sessionId;
      private List<string> _storageGroup;

      public long SessionId
      {
        get
        {
          return _sessionId;
        }
        set
        {
          __isset.sessionId = true;
          this._sessionId = value;
        }
      }

      public List<string> StorageGroup
      {
        get
        {
          return _storageGroup;
        }
        set
        {
          __isset.storageGroup = true;
          this._storageGroup = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool sessionId;
        public bool storageGroup;
      }

      public deleteStorageGroupsArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.I64)
                {
                  SessionId = await iprot.ReadI64Async(cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              case 2:
                if (field.Type == TType.List)
                {
                  {
                    TList _list475 = await iprot.ReadListBeginAsync(cancellationToken);
                    StorageGroup = new List<string>(_list475.Count);
                    for(int _i476 = 0; _i476 < _list475.Count; ++_i476)
                    {
                      string _elem477;
                      _elem477 = await iprot.ReadStringAsync(cancellationToken);
                      StorageGroup.Add(_elem477);
                    }
                    await iprot.ReadListEndAsync(cancellationToken);
                  }
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("deleteStorageGroups_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if(__isset.sessionId)
          {
            field.Name = "sessionId";
            field.Type = TType.I64;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI64Async(SessionId, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          if((StorageGroup != null) && __isset.storageGroup)
          {
            field.Name = "storageGroup";
            field.Type = TType.List;
            field.ID = 2;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            {
              await oprot.WriteListBeginAsync(new TList(TType.String, StorageGroup.Count), cancellationToken);
              foreach (string _iter478 in StorageGroup)
              {
                await oprot.WriteStringAsync(_iter478, cancellationToken);
              }
              await oprot.WriteListEndAsync(cancellationToken);
            }
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is deleteStorageGroupsArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.sessionId == other.__isset.sessionId) && ((!__isset.sessionId) || (System.Object.Equals(SessionId, other.SessionId))))
          && ((__isset.storageGroup == other.__isset.storageGroup) && ((!__isset.storageGroup) || (TCollections.Equals(StorageGroup, other.StorageGroup))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if(__isset.sessionId)
          {
            hashcode = (hashcode * 397) + SessionId.GetHashCode();
          }
          if((StorageGroup != null) && __isset.storageGroup)
          {
            hashcode = (hashcode * 397) + TCollections.GetHashCode(StorageGroup);
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("deleteStorageGroups_args(");
        int tmp479 = 0;
        if(__isset.sessionId)
        {
          if(0 < tmp479++) { sb.Append(", "); }
          sb.Append("SessionId: ");
          SessionId.ToString(sb);
        }
        if((StorageGroup != null) && __isset.storageGroup)
        {
          if(0 < tmp479++) { sb.Append(", "); }
          sb.Append("StorageGroup: ");
          StorageGroup.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class deleteStorageGroupsResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public deleteStorageGroupsResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("deleteStorageGroups_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is deleteStorageGroupsResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("deleteStorageGroups_result(");
        int tmp480 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp480++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertRecordArgs : TBase
    {
      private TSInsertRecordReq _req;

      public TSInsertRecordReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public insertRecordArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertRecordReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertRecord_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertRecordArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertRecord_args(");
        int tmp481 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp481++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertRecordResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public insertRecordResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertRecord_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertRecordResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertRecord_result(");
        int tmp482 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp482++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertStringRecordArgs : TBase
    {
      private TSInsertStringRecordReq _req;

      public TSInsertStringRecordReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public insertStringRecordArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertStringRecordReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertStringRecord_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertStringRecordArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertStringRecord_args(");
        int tmp483 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp483++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertStringRecordResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public insertStringRecordResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertStringRecord_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertStringRecordResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertStringRecord_result(");
        int tmp484 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp484++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertTabletArgs : TBase
    {
      private TSInsertTabletReq _req;

      public TSInsertTabletReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public insertTabletArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertTabletReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertTablet_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertTabletArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertTablet_args(");
        int tmp485 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp485++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertTabletResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public insertTabletResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertTablet_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertTabletResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertTablet_result(");
        int tmp486 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp486++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertTabletsArgs : TBase
    {
      private TSInsertTabletsReq _req;

      public TSInsertTabletsReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public insertTabletsArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertTabletsReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertTablets_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertTabletsArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertTablets_args(");
        int tmp487 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp487++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertTabletsResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public insertTabletsResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertTablets_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertTabletsResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertTablets_result(");
        int tmp488 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp488++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertRecordsArgs : TBase
    {
      private TSInsertRecordsReq _req;

      public TSInsertRecordsReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public insertRecordsArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertRecordsReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertRecords_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertRecordsArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertRecords_args(");
        int tmp489 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp489++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertRecordsResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public insertRecordsResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertRecords_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertRecordsResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertRecords_result(");
        int tmp490 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp490++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertRecordsOfOneDeviceArgs : TBase
    {
      private TSInsertRecordsOfOneDeviceReq _req;

      public TSInsertRecordsOfOneDeviceReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public insertRecordsOfOneDeviceArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertRecordsOfOneDeviceReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertRecordsOfOneDevice_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertRecordsOfOneDeviceArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertRecordsOfOneDevice_args(");
        int tmp491 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp491++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertRecordsOfOneDeviceResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public insertRecordsOfOneDeviceResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertRecordsOfOneDevice_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertRecordsOfOneDeviceResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertRecordsOfOneDevice_result(");
        int tmp492 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp492++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertStringRecordsOfOneDeviceArgs : TBase
    {
      private TSInsertStringRecordsOfOneDeviceReq _req;

      public TSInsertStringRecordsOfOneDeviceReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public insertStringRecordsOfOneDeviceArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertStringRecordsOfOneDeviceReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertStringRecordsOfOneDevice_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertStringRecordsOfOneDeviceArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertStringRecordsOfOneDevice_args(");
        int tmp493 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp493++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertStringRecordsOfOneDeviceResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public insertStringRecordsOfOneDeviceResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertStringRecordsOfOneDevice_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertStringRecordsOfOneDeviceResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertStringRecordsOfOneDevice_result(");
        int tmp494 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp494++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertStringRecordsArgs : TBase
    {
      private TSInsertStringRecordsReq _req;

      public TSInsertStringRecordsReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public insertStringRecordsArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertStringRecordsReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertStringRecords_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertStringRecordsArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertStringRecords_args(");
        int tmp495 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp495++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class insertStringRecordsResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public insertStringRecordsResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("insertStringRecords_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is insertStringRecordsResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("insertStringRecords_result(");
        int tmp496 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp496++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertTabletArgs : TBase
    {
      private TSInsertTabletReq _req;

      public TSInsertTabletReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public testInsertTabletArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertTabletReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertTablet_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertTabletArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertTablet_args(");
        int tmp497 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp497++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertTabletResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public testInsertTabletResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertTablet_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertTabletResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertTablet_result(");
        int tmp498 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp498++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertTabletsArgs : TBase
    {
      private TSInsertTabletsReq _req;

      public TSInsertTabletsReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public testInsertTabletsArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertTabletsReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertTablets_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertTabletsArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertTablets_args(");
        int tmp499 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp499++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertTabletsResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public testInsertTabletsResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertTablets_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertTabletsResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertTablets_result(");
        int tmp500 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp500++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertRecordArgs : TBase
    {
      private TSInsertRecordReq _req;

      public TSInsertRecordReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public testInsertRecordArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertRecordReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertRecord_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertRecordArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertRecord_args(");
        int tmp501 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp501++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertRecordResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public testInsertRecordResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertRecord_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertRecordResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertRecord_result(");
        int tmp502 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp502++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertStringRecordArgs : TBase
    {
      private TSInsertStringRecordReq _req;

      public TSInsertStringRecordReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public testInsertStringRecordArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertStringRecordReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertStringRecord_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertStringRecordArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertStringRecord_args(");
        int tmp503 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp503++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertStringRecordResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public testInsertStringRecordResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertStringRecord_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertStringRecordResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertStringRecord_result(");
        int tmp504 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp504++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertRecordsArgs : TBase
    {
      private TSInsertRecordsReq _req;

      public TSInsertRecordsReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public testInsertRecordsArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertRecordsReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertRecords_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertRecordsArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertRecords_args(");
        int tmp505 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp505++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertRecordsResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public testInsertRecordsResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertRecords_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertRecordsResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertRecords_result(");
        int tmp506 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp506++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertRecordsOfOneDeviceArgs : TBase
    {
      private TSInsertRecordsOfOneDeviceReq _req;

      public TSInsertRecordsOfOneDeviceReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public testInsertRecordsOfOneDeviceArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertRecordsOfOneDeviceReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertRecordsOfOneDevice_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertRecordsOfOneDeviceArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertRecordsOfOneDevice_args(");
        int tmp507 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp507++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertRecordsOfOneDeviceResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public testInsertRecordsOfOneDeviceResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertRecordsOfOneDevice_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertRecordsOfOneDeviceResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertRecordsOfOneDevice_result(");
        int tmp508 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp508++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertStringRecordsArgs : TBase
    {
      private TSInsertStringRecordsReq _req;

      public TSInsertStringRecordsReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public testInsertStringRecordsArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSInsertStringRecordsReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertStringRecords_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertStringRecordsArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertStringRecords_args(");
        int tmp509 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp509++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testInsertStringRecordsResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public testInsertStringRecordsResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testInsertStringRecords_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testInsertStringRecordsResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testInsertStringRecords_result(");
        int tmp510 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp510++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class deleteDataArgs : TBase
    {
      private TSDeleteDataReq _req;

      public TSDeleteDataReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public deleteDataArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSDeleteDataReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("deleteData_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is deleteDataArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("deleteData_args(");
        int tmp511 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp511++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class deleteDataResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public deleteDataResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("deleteData_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is deleteDataResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("deleteData_result(");
        int tmp512 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp512++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeRawDataQueryArgs : TBase
    {
      private TSRawDataQueryReq _req;

      public TSRawDataQueryReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeRawDataQueryArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSRawDataQueryReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeRawDataQuery_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeRawDataQueryArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeRawDataQuery_args(");
        int tmp513 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp513++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeRawDataQueryResult : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeRawDataQueryResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeRawDataQuery_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeRawDataQueryResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeRawDataQuery_result(");
        int tmp514 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp514++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeLastDataQueryArgs : TBase
    {
      private TSLastDataQueryReq _req;

      public TSLastDataQueryReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeLastDataQueryArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSLastDataQueryReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeLastDataQuery_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeLastDataQueryArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeLastDataQuery_args(");
        int tmp515 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp515++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeLastDataQueryResult : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeLastDataQueryResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeLastDataQuery_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeLastDataQueryResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeLastDataQuery_result(");
        int tmp516 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp516++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeAggregationQueryArgs : TBase
    {
      private TSAggregationQueryReq _req;

      public TSAggregationQueryReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public executeAggregationQueryArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSAggregationQueryReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeAggregationQuery_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeAggregationQueryArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeAggregationQuery_args(");
        int tmp517 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp517++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class executeAggregationQueryResult : TBase
    {
      private TSExecuteStatementResp _success;

      public TSExecuteStatementResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public executeAggregationQueryResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSExecuteStatementResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("executeAggregationQuery_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is executeAggregationQueryResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("executeAggregationQuery_result(");
        int tmp518 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp518++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class requestStatementIdArgs : TBase
    {
      private long _sessionId;

      public long SessionId
      {
        get
        {
          return _sessionId;
        }
        set
        {
          __isset.sessionId = true;
          this._sessionId = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool sessionId;
      }

      public requestStatementIdArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.I64)
                {
                  SessionId = await iprot.ReadI64Async(cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("requestStatementId_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if(__isset.sessionId)
          {
            field.Name = "sessionId";
            field.Type = TType.I64;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI64Async(SessionId, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is requestStatementIdArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.sessionId == other.__isset.sessionId) && ((!__isset.sessionId) || (System.Object.Equals(SessionId, other.SessionId))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if(__isset.sessionId)
          {
            hashcode = (hashcode * 397) + SessionId.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("requestStatementId_args(");
        int tmp519 = 0;
        if(__isset.sessionId)
        {
          if(0 < tmp519++) { sb.Append(", "); }
          sb.Append("SessionId: ");
          SessionId.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class requestStatementIdResult : TBase
    {
      private long _success;

      public long Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public requestStatementIdResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.I64)
                {
                  Success = await iprot.ReadI64Async(cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("requestStatementId_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            field.Name = "Success";
            field.Type = TType.I64;
            field.ID = 0;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI64Async(Success, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is requestStatementIdResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if(__isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("requestStatementId_result(");
        int tmp520 = 0;
        if(__isset.success)
        {
          if(0 < tmp520++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class createSchemaTemplateArgs : TBase
    {
      private TSCreateSchemaTemplateReq _req;

      public TSCreateSchemaTemplateReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public createSchemaTemplateArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSCreateSchemaTemplateReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("createSchemaTemplate_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is createSchemaTemplateArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("createSchemaTemplate_args(");
        int tmp521 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp521++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class createSchemaTemplateResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public createSchemaTemplateResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("createSchemaTemplate_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is createSchemaTemplateResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("createSchemaTemplate_result(");
        int tmp522 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp522++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class appendSchemaTemplateArgs : TBase
    {
      private TSAppendSchemaTemplateReq _req;

      public TSAppendSchemaTemplateReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public appendSchemaTemplateArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSAppendSchemaTemplateReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("appendSchemaTemplate_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is appendSchemaTemplateArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("appendSchemaTemplate_args(");
        int tmp523 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp523++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class appendSchemaTemplateResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public appendSchemaTemplateResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("appendSchemaTemplate_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is appendSchemaTemplateResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("appendSchemaTemplate_result(");
        int tmp524 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp524++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class pruneSchemaTemplateArgs : TBase
    {
      private TSPruneSchemaTemplateReq _req;

      public TSPruneSchemaTemplateReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public pruneSchemaTemplateArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSPruneSchemaTemplateReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("pruneSchemaTemplate_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is pruneSchemaTemplateArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("pruneSchemaTemplate_args(");
        int tmp525 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp525++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class pruneSchemaTemplateResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public pruneSchemaTemplateResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("pruneSchemaTemplate_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is pruneSchemaTemplateResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("pruneSchemaTemplate_result(");
        int tmp526 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp526++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class querySchemaTemplateArgs : TBase
    {
      private TSQueryTemplateReq _req;

      public TSQueryTemplateReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public querySchemaTemplateArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSQueryTemplateReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("querySchemaTemplate_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is querySchemaTemplateArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("querySchemaTemplate_args(");
        int tmp527 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp527++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class querySchemaTemplateResult : TBase
    {
      private TSQueryTemplateResp _success;

      public TSQueryTemplateResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public querySchemaTemplateResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSQueryTemplateResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("querySchemaTemplate_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is querySchemaTemplateResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("querySchemaTemplate_result(");
        int tmp528 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp528++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class showConfigurationTemplateArgs : TBase
    {

      public showConfigurationTemplateArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("showConfigurationTemplate_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is showConfigurationTemplateArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return true;
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("showConfigurationTemplate_args(");
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class showConfigurationTemplateResult : TBase
    {
      private TShowConfigurationTemplateResp _success;

      public TShowConfigurationTemplateResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public showConfigurationTemplateResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TShowConfigurationTemplateResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("showConfigurationTemplate_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is showConfigurationTemplateResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("showConfigurationTemplate_result(");
        int tmp530 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp530++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class showConfigurationArgs : TBase
    {
      private int _nodeId;

      public int NodeId
      {
        get
        {
          return _nodeId;
        }
        set
        {
          __isset.nodeId = true;
          this._nodeId = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool nodeId;
      }

      public showConfigurationArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.I32)
                {
                  NodeId = await iprot.ReadI32Async(cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("showConfiguration_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if(__isset.nodeId)
          {
            field.Name = "nodeId";
            field.Type = TType.I32;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async(NodeId, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is showConfigurationArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.nodeId == other.__isset.nodeId) && ((!__isset.nodeId) || (System.Object.Equals(NodeId, other.NodeId))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if(__isset.nodeId)
          {
            hashcode = (hashcode * 397) + NodeId.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("showConfiguration_args(");
        int tmp531 = 0;
        if(__isset.nodeId)
        {
          if(0 < tmp531++) { sb.Append(", "); }
          sb.Append("NodeId: ");
          NodeId.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class showConfigurationResult : TBase
    {
      private TShowConfigurationResp _success;

      public TShowConfigurationResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public showConfigurationResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TShowConfigurationResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("showConfiguration_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is showConfigurationResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("showConfiguration_result(");
        int tmp532 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp532++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class setSchemaTemplateArgs : TBase
    {
      private TSSetSchemaTemplateReq _req;

      public TSSetSchemaTemplateReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public setSchemaTemplateArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSSetSchemaTemplateReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("setSchemaTemplate_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is setSchemaTemplateArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("setSchemaTemplate_args(");
        int tmp533 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp533++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class setSchemaTemplateResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public setSchemaTemplateResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("setSchemaTemplate_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is setSchemaTemplateResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("setSchemaTemplate_result(");
        int tmp534 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp534++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class unsetSchemaTemplateArgs : TBase
    {
      private TSUnsetSchemaTemplateReq _req;

      public TSUnsetSchemaTemplateReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public unsetSchemaTemplateArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSUnsetSchemaTemplateReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("unsetSchemaTemplate_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is unsetSchemaTemplateArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("unsetSchemaTemplate_args(");
        int tmp535 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp535++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class unsetSchemaTemplateResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public unsetSchemaTemplateResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("unsetSchemaTemplate_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is unsetSchemaTemplateResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("unsetSchemaTemplate_result(");
        int tmp536 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp536++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class dropSchemaTemplateArgs : TBase
    {
      private TSDropSchemaTemplateReq _req;

      public TSDropSchemaTemplateReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public dropSchemaTemplateArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TSDropSchemaTemplateReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("dropSchemaTemplate_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is dropSchemaTemplateArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("dropSchemaTemplate_args(");
        int tmp537 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp537++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class dropSchemaTemplateResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public dropSchemaTemplateResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("dropSchemaTemplate_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is dropSchemaTemplateResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("dropSchemaTemplate_result(");
        int tmp538 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp538++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class createTimeseriesUsingSchemaTemplateArgs : TBase
    {
      private TCreateTimeseriesUsingSchemaTemplateReq _req;

      public TCreateTimeseriesUsingSchemaTemplateReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public createTimeseriesUsingSchemaTemplateArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  Req = new TCreateTimeseriesUsingSchemaTemplateReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("createTimeseriesUsingSchemaTemplate_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is createTimeseriesUsingSchemaTemplateArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("createTimeseriesUsingSchemaTemplate_args(");
        int tmp539 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp539++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class createTimeseriesUsingSchemaTemplateResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public createTimeseriesUsingSchemaTemplateResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("createTimeseriesUsingSchemaTemplate_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is createTimeseriesUsingSchemaTemplateResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("createTimeseriesUsingSchemaTemplate_result(");
        int tmp540 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp540++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class handshakeArgs : TBase
    {
      private TSyncIdentityInfo _info;

      public TSyncIdentityInfo Info
      {
        get
        {
          return _info;
        }
        set
        {
          __isset.info = true;
          this._info = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool info;
      }

      public handshakeArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case -1:
                if (field.Type == TType.Struct)
                {
                  Info = new TSyncIdentityInfo();
                  await Info.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("handshake_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Info != null) && __isset.info)
          {
            field.Name = "info";
            field.Type = TType.Struct;
            field.ID = -1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Info.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is handshakeArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.info == other.__isset.info) && ((!__isset.info) || (System.Object.Equals(Info, other.Info))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Info != null) && __isset.info)
          {
            hashcode = (hashcode * 397) + Info.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("handshake_args(");
        int tmp541 = 0;
        if((Info != null) && __isset.info)
        {
          if(0 < tmp541++) { sb.Append(", "); }
          sb.Append("Info: ");
          Info.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class handshakeResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public handshakeResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("handshake_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is handshakeResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("handshake_result(");
        int tmp542 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp542++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class sendPipeDataArgs : TBase
    {
      private byte[] _buff;

      public byte[] Buff
      {
        get
        {
          return _buff;
        }
        set
        {
          __isset.buff = true;
          this._buff = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool buff;
      }

      public sendPipeDataArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.String)
                {
                  Buff = await iprot.ReadBinaryAsync(cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("sendPipeData_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Buff != null) && __isset.buff)
          {
            field.Name = "buff";
            field.Type = TType.String;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteBinaryAsync(Buff, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is sendPipeDataArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.buff == other.__isset.buff) && ((!__isset.buff) || (TCollections.Equals(Buff, other.Buff))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Buff != null) && __isset.buff)
          {
            hashcode = (hashcode * 397) + Buff.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("sendPipeData_args(");
        int tmp543 = 0;
        if((Buff != null) && __isset.buff)
        {
          if(0 < tmp543++) { sb.Append(", "); }
          sb.Append("Buff: ");
          Buff.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class sendPipeDataResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public sendPipeDataResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("sendPipeData_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is sendPipeDataResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("sendPipeData_result(");
        int tmp544 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp544++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class sendFileArgs : TBase
    {
      private TSyncTransportMetaInfo _metaInfo;
      private byte[] _buff;

      public TSyncTransportMetaInfo MetaInfo
      {
        get
        {
          return _metaInfo;
        }
        set
        {
          __isset.metaInfo = true;
          this._metaInfo = value;
        }
      }

      public byte[] Buff
      {
        get
        {
          return _buff;
        }
        set
        {
          __isset.buff = true;
          this._buff = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool metaInfo;
        public bool buff;
      }

      public sendFileArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 1:
                if (field.Type == TType.Struct)
                {
                  MetaInfo = new TSyncTransportMetaInfo();
                  await MetaInfo.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              case 2:
                if (field.Type == TType.String)
                {
                  Buff = await iprot.ReadBinaryAsync(cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("sendFile_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((MetaInfo != null) && __isset.metaInfo)
          {
            field.Name = "metaInfo";
            field.Type = TType.Struct;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await MetaInfo.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          if((Buff != null) && __isset.buff)
          {
            field.Name = "buff";
            field.Type = TType.String;
            field.ID = 2;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteBinaryAsync(Buff, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is sendFileArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.metaInfo == other.__isset.metaInfo) && ((!__isset.metaInfo) || (System.Object.Equals(MetaInfo, other.MetaInfo))))
          && ((__isset.buff == other.__isset.buff) && ((!__isset.buff) || (TCollections.Equals(Buff, other.Buff))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((MetaInfo != null) && __isset.metaInfo)
          {
            hashcode = (hashcode * 397) + MetaInfo.GetHashCode();
          }
          if((Buff != null) && __isset.buff)
          {
            hashcode = (hashcode * 397) + Buff.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("sendFile_args(");
        int tmp545 = 0;
        if((MetaInfo != null) && __isset.metaInfo)
        {
          if(0 < tmp545++) { sb.Append(", "); }
          sb.Append("MetaInfo: ");
          MetaInfo.ToString(sb);
        }
        if((Buff != null) && __isset.buff)
        {
          if(0 < tmp545++) { sb.Append(", "); }
          sb.Append("Buff: ");
          Buff.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class sendFileResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public sendFileResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("sendFile_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is sendFileResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("sendFile_result(");
        int tmp546 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp546++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class pipeTransferArgs : TBase
    {
      private TPipeTransferReq _req;

      public TPipeTransferReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public pipeTransferArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case -1:
                if (field.Type == TType.Struct)
                {
                  Req = new TPipeTransferReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("pipeTransfer_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = -1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is pipeTransferArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("pipeTransfer_args(");
        int tmp547 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp547++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class pipeTransferResult : TBase
    {
      private TPipeTransferResp _success;

      public TPipeTransferResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public pipeTransferResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TPipeTransferResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("pipeTransfer_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is pipeTransferResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("pipeTransfer_result(");
        int tmp548 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp548++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class pipeSubscribeArgs : TBase
    {
      private TPipeSubscribeReq _req;

      public TPipeSubscribeReq Req
      {
        get
        {
          return _req;
        }
        set
        {
          __isset.req = true;
          this._req = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool req;
      }

      public pipeSubscribeArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case -1:
                if (field.Type == TType.Struct)
                {
                  Req = new TPipeSubscribeReq();
                  await Req.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("pipeSubscribe_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();
          if((Req != null) && __isset.req)
          {
            field.Name = "req";
            field.Type = TType.Struct;
            field.ID = -1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await Req.WriteAsync(oprot, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is pipeSubscribeArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.req == other.__isset.req) && ((!__isset.req) || (System.Object.Equals(Req, other.Req))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Req != null) && __isset.req)
          {
            hashcode = (hashcode * 397) + Req.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("pipeSubscribe_args(");
        int tmp549 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp549++) { sb.Append(", "); }
          sb.Append("Req: ");
          Req.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class pipeSubscribeResult : TBase
    {
      private TPipeSubscribeResp _success;

      public TPipeSubscribeResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public pipeSubscribeResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TPipeSubscribeResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("pipeSubscribe_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is pipeSubscribeResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("pipeSubscribe_result(");
        int tmp550 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp550++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class getBackupConfigurationArgs : TBase
    {

      public getBackupConfigurationArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("getBackupConfiguration_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is getBackupConfigurationArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return true;
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("getBackupConfiguration_args(");
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class getBackupConfigurationResult : TBase
    {
      private TSBackupConfigurationResp _success;

      public TSBackupConfigurationResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public getBackupConfigurationResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSBackupConfigurationResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("getBackupConfiguration_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is getBackupConfigurationResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("getBackupConfiguration_result(");
        int tmp552 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp552++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class fetchAllConnectionsInfoArgs : TBase
    {

      public fetchAllConnectionsInfoArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("fetchAllConnectionsInfo_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is fetchAllConnectionsInfoArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return true;
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("fetchAllConnectionsInfo_args(");
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class fetchAllConnectionsInfoResult : TBase
    {
      private TSConnectionInfoResp _success;

      public TSConnectionInfoResp Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public fetchAllConnectionsInfoResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSConnectionInfoResp();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("fetchAllConnectionsInfo_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is fetchAllConnectionsInfoResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("fetchAllConnectionsInfo_result(");
        int tmp554 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp554++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testConnectionEmptyRPCArgs : TBase
    {

      public testConnectionEmptyRPCArgs()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testConnectionEmptyRPC_args");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testConnectionEmptyRPCArgs other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return true;
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testConnectionEmptyRPC_args(");
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class testConnectionEmptyRPCResult : TBase
    {
      private TSStatus _success;

      public TSStatus Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      public struct Isset
      {
        public bool success;
      }

      public testConnectionEmptyRPCResult()
      {
      }

      public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
      {
        iprot.IncrementRecursionDepth();
        try
        {
          TField field;
          await iprot.ReadStructBeginAsync(cancellationToken);
          while (true)
          {
            field = await iprot.ReadFieldBeginAsync(cancellationToken);
            if (field.Type == TType.Stop)
            {
              break;
            }

            switch (field.ID)
            {
              case 0:
                if (field.Type == TType.Struct)
                {
                  Success = new TSStatus();
                  await Success.ReadAsync(iprot, cancellationToken);
                }
                else
                {
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                }
                break;
              default: 
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                break;
            }

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

          await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
          iprot.DecrementRecursionDepth();
        }
      }

      public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
      {
        oprot.IncrementRecursionDepth();
        try
        {
          var struc = new TStruct("testConnectionEmptyRPC_result");
          await oprot.WriteStructBeginAsync(struc, cancellationToken);
          var field = new TField();

          if(this.__isset.success)
          {
            if (Success != null)
            {
              field.Name = "Success";
              field.Type = TType.Struct;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Success.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
          }
          await oprot.WriteFieldStopAsync(cancellationToken);
          await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
          oprot.DecrementRecursionDepth();
        }
      }

      public override bool Equals(object that)
      {
        if (!(that is testConnectionEmptyRPCResult other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))));
      }

      public override int GetHashCode() {
        int hashcode = 157;
        unchecked {
          if((Success != null) && __isset.success)
          {
            hashcode = (hashcode * 397) + Success.GetHashCode();
          }
        }
        return hashcode;
      }

      public override string ToString()
      {
        var sb = new StringBuilder("testConnectionEmptyRPC_result(");
        int tmp556 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp556++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }

  }

}