src/Apache.IoTDB.Rpc.Generated/TSIService.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 TSIService
{
  public interface IAsync
  {
    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> 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> 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<long> requestStatementIdAsync(long sessionId, 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<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> 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> 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<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 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_["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_["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_["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_["requestStatementId"] = requestStatementId_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 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 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 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 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 class InternalStructs
  {

    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 openSessionArgs DeepCopy()
      {
        var tmp299 = new openSessionArgs();
        if((Req != null) && __isset.req)
        {
          tmp299.Req = (TSOpenSessionReq)this.Req.DeepCopy();
        }
        tmp299.__isset.req = this.__isset.req;
        return tmp299;
      }

      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 tmp300 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp300++) { 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 openSessionResult DeepCopy()
      {
        var tmp301 = new openSessionResult();
        if((Success != null) && __isset.success)
        {
          tmp301.Success = (TSOpenSessionResp)this.Success.DeepCopy();
        }
        tmp301.__isset.success = this.__isset.success;
        return tmp301;
      }

      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 tmp302 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp302++) { 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 closeSessionArgs DeepCopy()
      {
        var tmp303 = new closeSessionArgs();
        if((Req != null) && __isset.req)
        {
          tmp303.Req = (TSCloseSessionReq)this.Req.DeepCopy();
        }
        tmp303.__isset.req = this.__isset.req;
        return tmp303;
      }

      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 tmp304 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp304++) { 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 closeSessionResult DeepCopy()
      {
        var tmp305 = new closeSessionResult();
        if((Success != null) && __isset.success)
        {
          tmp305.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp305.__isset.success = this.__isset.success;
        return tmp305;
      }

      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 tmp306 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp306++) { 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 executeStatementArgs DeepCopy()
      {
        var tmp307 = new executeStatementArgs();
        if((Req != null) && __isset.req)
        {
          tmp307.Req = (TSExecuteStatementReq)this.Req.DeepCopy();
        }
        tmp307.__isset.req = this.__isset.req;
        return tmp307;
      }

      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 tmp308 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp308++) { 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 executeStatementResult DeepCopy()
      {
        var tmp309 = new executeStatementResult();
        if((Success != null) && __isset.success)
        {
          tmp309.Success = (TSExecuteStatementResp)this.Success.DeepCopy();
        }
        tmp309.__isset.success = this.__isset.success;
        return tmp309;
      }

      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 tmp310 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp310++) { 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 executeBatchStatementArgs DeepCopy()
      {
        var tmp311 = new executeBatchStatementArgs();
        if((Req != null) && __isset.req)
        {
          tmp311.Req = (TSExecuteBatchStatementReq)this.Req.DeepCopy();
        }
        tmp311.__isset.req = this.__isset.req;
        return tmp311;
      }

      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 tmp312 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp312++) { 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 executeBatchStatementResult DeepCopy()
      {
        var tmp313 = new executeBatchStatementResult();
        if((Success != null) && __isset.success)
        {
          tmp313.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp313.__isset.success = this.__isset.success;
        return tmp313;
      }

      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 tmp314 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp314++) { 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 executeQueryStatementArgs DeepCopy()
      {
        var tmp315 = new executeQueryStatementArgs();
        if((Req != null) && __isset.req)
        {
          tmp315.Req = (TSExecuteStatementReq)this.Req.DeepCopy();
        }
        tmp315.__isset.req = this.__isset.req;
        return tmp315;
      }

      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 tmp316 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp316++) { 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 executeQueryStatementResult DeepCopy()
      {
        var tmp317 = new executeQueryStatementResult();
        if((Success != null) && __isset.success)
        {
          tmp317.Success = (TSExecuteStatementResp)this.Success.DeepCopy();
        }
        tmp317.__isset.success = this.__isset.success;
        return tmp317;
      }

      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 tmp318 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp318++) { 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 executeUpdateStatementArgs DeepCopy()
      {
        var tmp319 = new executeUpdateStatementArgs();
        if((Req != null) && __isset.req)
        {
          tmp319.Req = (TSExecuteStatementReq)this.Req.DeepCopy();
        }
        tmp319.__isset.req = this.__isset.req;
        return tmp319;
      }

      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 tmp320 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp320++) { 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 executeUpdateStatementResult DeepCopy()
      {
        var tmp321 = new executeUpdateStatementResult();
        if((Success != null) && __isset.success)
        {
          tmp321.Success = (TSExecuteStatementResp)this.Success.DeepCopy();
        }
        tmp321.__isset.success = this.__isset.success;
        return tmp321;
      }

      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 tmp322 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp322++) { 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 fetchResultsArgs DeepCopy()
      {
        var tmp323 = new fetchResultsArgs();
        if((Req != null) && __isset.req)
        {
          tmp323.Req = (TSFetchResultsReq)this.Req.DeepCopy();
        }
        tmp323.__isset.req = this.__isset.req;
        return tmp323;
      }

      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 tmp324 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp324++) { 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 fetchResultsResult DeepCopy()
      {
        var tmp325 = new fetchResultsResult();
        if((Success != null) && __isset.success)
        {
          tmp325.Success = (TSFetchResultsResp)this.Success.DeepCopy();
        }
        tmp325.__isset.success = this.__isset.success;
        return tmp325;
      }

      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 tmp326 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp326++) { 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 fetchMetadataArgs DeepCopy()
      {
        var tmp327 = new fetchMetadataArgs();
        if((Req != null) && __isset.req)
        {
          tmp327.Req = (TSFetchMetadataReq)this.Req.DeepCopy();
        }
        tmp327.__isset.req = this.__isset.req;
        return tmp327;
      }

      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 tmp328 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp328++) { 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 fetchMetadataResult DeepCopy()
      {
        var tmp329 = new fetchMetadataResult();
        if((Success != null) && __isset.success)
        {
          tmp329.Success = (TSFetchMetadataResp)this.Success.DeepCopy();
        }
        tmp329.__isset.success = this.__isset.success;
        return tmp329;
      }

      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 tmp330 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp330++) { 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 cancelOperationArgs DeepCopy()
      {
        var tmp331 = new cancelOperationArgs();
        if((Req != null) && __isset.req)
        {
          tmp331.Req = (TSCancelOperationReq)this.Req.DeepCopy();
        }
        tmp331.__isset.req = this.__isset.req;
        return tmp331;
      }

      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 tmp332 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp332++) { 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 cancelOperationResult DeepCopy()
      {
        var tmp333 = new cancelOperationResult();
        if((Success != null) && __isset.success)
        {
          tmp333.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp333.__isset.success = this.__isset.success;
        return tmp333;
      }

      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 tmp334 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp334++) { 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 closeOperationArgs DeepCopy()
      {
        var tmp335 = new closeOperationArgs();
        if((Req != null) && __isset.req)
        {
          tmp335.Req = (TSCloseOperationReq)this.Req.DeepCopy();
        }
        tmp335.__isset.req = this.__isset.req;
        return tmp335;
      }

      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 tmp336 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp336++) { 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 closeOperationResult DeepCopy()
      {
        var tmp337 = new closeOperationResult();
        if((Success != null) && __isset.success)
        {
          tmp337.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp337.__isset.success = this.__isset.success;
        return tmp337;
      }

      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 tmp338 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp338++) { 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 getTimeZoneArgs DeepCopy()
      {
        var tmp339 = new getTimeZoneArgs();
        if(__isset.sessionId)
        {
          tmp339.SessionId = this.SessionId;
        }
        tmp339.__isset.sessionId = this.__isset.sessionId;
        return tmp339;
      }

      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 tmp340 = 0;
        if(__isset.sessionId)
        {
          if(0 < tmp340++) { 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 getTimeZoneResult DeepCopy()
      {
        var tmp341 = new getTimeZoneResult();
        if((Success != null) && __isset.success)
        {
          tmp341.Success = (TSGetTimeZoneResp)this.Success.DeepCopy();
        }
        tmp341.__isset.success = this.__isset.success;
        return tmp341;
      }

      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 tmp342 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp342++) { 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 setTimeZoneArgs DeepCopy()
      {
        var tmp343 = new setTimeZoneArgs();
        if((Req != null) && __isset.req)
        {
          tmp343.Req = (TSSetTimeZoneReq)this.Req.DeepCopy();
        }
        tmp343.__isset.req = this.__isset.req;
        return tmp343;
      }

      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 tmp344 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp344++) { 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 setTimeZoneResult DeepCopy()
      {
        var tmp345 = new setTimeZoneResult();
        if((Success != null) && __isset.success)
        {
          tmp345.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp345.__isset.success = this.__isset.success;
        return tmp345;
      }

      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 tmp346 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp346++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class getPropertiesArgs : TBase
    {

      public getPropertiesArgs()
      {
      }

      public getPropertiesArgs DeepCopy()
      {
        var tmp347 = new getPropertiesArgs();
        return tmp347;
      }

      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 getPropertiesResult DeepCopy()
      {
        var tmp349 = new getPropertiesResult();
        if((Success != null) && __isset.success)
        {
          tmp349.Success = (ServerProperties)this.Success.DeepCopy();
        }
        tmp349.__isset.success = this.__isset.success;
        return tmp349;
      }

      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 tmp350 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp350++) { 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 setStorageGroupArgs DeepCopy()
      {
        var tmp351 = new setStorageGroupArgs();
        if(__isset.sessionId)
        {
          tmp351.SessionId = this.SessionId;
        }
        tmp351.__isset.sessionId = this.__isset.sessionId;
        if((StorageGroup != null) && __isset.storageGroup)
        {
          tmp351.StorageGroup = this.StorageGroup;
        }
        tmp351.__isset.storageGroup = this.__isset.storageGroup;
        return tmp351;
      }

      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 tmp352 = 0;
        if(__isset.sessionId)
        {
          if(0 < tmp352++) { sb.Append(", "); }
          sb.Append("SessionId: ");
          SessionId.ToString(sb);
        }
        if((StorageGroup != null) && __isset.storageGroup)
        {
          if(0 < tmp352++) { 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 setStorageGroupResult DeepCopy()
      {
        var tmp353 = new setStorageGroupResult();
        if((Success != null) && __isset.success)
        {
          tmp353.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp353.__isset.success = this.__isset.success;
        return tmp353;
      }

      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 tmp354 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp354++) { 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 createTimeseriesArgs DeepCopy()
      {
        var tmp355 = new createTimeseriesArgs();
        if((Req != null) && __isset.req)
        {
          tmp355.Req = (TSCreateTimeseriesReq)this.Req.DeepCopy();
        }
        tmp355.__isset.req = this.__isset.req;
        return tmp355;
      }

      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 tmp356 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp356++) { 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 createTimeseriesResult DeepCopy()
      {
        var tmp357 = new createTimeseriesResult();
        if((Success != null) && __isset.success)
        {
          tmp357.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp357.__isset.success = this.__isset.success;
        return tmp357;
      }

      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 tmp358 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp358++) { 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 createMultiTimeseriesArgs DeepCopy()
      {
        var tmp359 = new createMultiTimeseriesArgs();
        if((Req != null) && __isset.req)
        {
          tmp359.Req = (TSCreateMultiTimeseriesReq)this.Req.DeepCopy();
        }
        tmp359.__isset.req = this.__isset.req;
        return tmp359;
      }

      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 tmp360 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp360++) { 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 createMultiTimeseriesResult DeepCopy()
      {
        var tmp361 = new createMultiTimeseriesResult();
        if((Success != null) && __isset.success)
        {
          tmp361.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp361.__isset.success = this.__isset.success;
        return tmp361;
      }

      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 tmp362 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp362++) { 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 deleteTimeseriesArgs DeepCopy()
      {
        var tmp363 = new deleteTimeseriesArgs();
        if(__isset.sessionId)
        {
          tmp363.SessionId = this.SessionId;
        }
        tmp363.__isset.sessionId = this.__isset.sessionId;
        if((Path != null) && __isset.path)
        {
          tmp363.Path = this.Path.DeepCopy();
        }
        tmp363.__isset.path = this.__isset.path;
        return tmp363;
      }

      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 _list364 = await iprot.ReadListBeginAsync(cancellationToken);
                    Path = new List<string>(_list364.Count);
                    for(int _i365 = 0; _i365 < _list364.Count; ++_i365)
                    {
                      string _elem366;
                      _elem366 = await iprot.ReadStringAsync(cancellationToken);
                      Path.Add(_elem366);
                    }
                    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 _iter367 in Path)
              {
                await oprot.WriteStringAsync(_iter367, 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 tmp368 = 0;
        if(__isset.sessionId)
        {
          if(0 < tmp368++) { sb.Append(", "); }
          sb.Append("SessionId: ");
          SessionId.ToString(sb);
        }
        if((Path != null) && __isset.path)
        {
          if(0 < tmp368++) { 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 deleteTimeseriesResult DeepCopy()
      {
        var tmp369 = new deleteTimeseriesResult();
        if((Success != null) && __isset.success)
        {
          tmp369.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp369.__isset.success = this.__isset.success;
        return tmp369;
      }

      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 tmp370 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp370++) { 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 deleteStorageGroupsArgs DeepCopy()
      {
        var tmp371 = new deleteStorageGroupsArgs();
        if(__isset.sessionId)
        {
          tmp371.SessionId = this.SessionId;
        }
        tmp371.__isset.sessionId = this.__isset.sessionId;
        if((StorageGroup != null) && __isset.storageGroup)
        {
          tmp371.StorageGroup = this.StorageGroup.DeepCopy();
        }
        tmp371.__isset.storageGroup = this.__isset.storageGroup;
        return tmp371;
      }

      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 _list372 = await iprot.ReadListBeginAsync(cancellationToken);
                    StorageGroup = new List<string>(_list372.Count);
                    for(int _i373 = 0; _i373 < _list372.Count; ++_i373)
                    {
                      string _elem374;
                      _elem374 = await iprot.ReadStringAsync(cancellationToken);
                      StorageGroup.Add(_elem374);
                    }
                    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 _iter375 in StorageGroup)
              {
                await oprot.WriteStringAsync(_iter375, 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 tmp376 = 0;
        if(__isset.sessionId)
        {
          if(0 < tmp376++) { sb.Append(", "); }
          sb.Append("SessionId: ");
          SessionId.ToString(sb);
        }
        if((StorageGroup != null) && __isset.storageGroup)
        {
          if(0 < tmp376++) { 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 deleteStorageGroupsResult DeepCopy()
      {
        var tmp377 = new deleteStorageGroupsResult();
        if((Success != null) && __isset.success)
        {
          tmp377.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp377.__isset.success = this.__isset.success;
        return tmp377;
      }

      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 tmp378 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp378++) { 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 insertRecordArgs DeepCopy()
      {
        var tmp379 = new insertRecordArgs();
        if((Req != null) && __isset.req)
        {
          tmp379.Req = (TSInsertRecordReq)this.Req.DeepCopy();
        }
        tmp379.__isset.req = this.__isset.req;
        return tmp379;
      }

      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 tmp380 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp380++) { 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 insertRecordResult DeepCopy()
      {
        var tmp381 = new insertRecordResult();
        if((Success != null) && __isset.success)
        {
          tmp381.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp381.__isset.success = this.__isset.success;
        return tmp381;
      }

      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 tmp382 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp382++) { 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 insertStringRecordArgs DeepCopy()
      {
        var tmp383 = new insertStringRecordArgs();
        if((Req != null) && __isset.req)
        {
          tmp383.Req = (TSInsertStringRecordReq)this.Req.DeepCopy();
        }
        tmp383.__isset.req = this.__isset.req;
        return tmp383;
      }

      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 tmp384 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp384++) { 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 insertStringRecordResult DeepCopy()
      {
        var tmp385 = new insertStringRecordResult();
        if((Success != null) && __isset.success)
        {
          tmp385.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp385.__isset.success = this.__isset.success;
        return tmp385;
      }

      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 tmp386 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp386++) { 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 insertTabletArgs DeepCopy()
      {
        var tmp387 = new insertTabletArgs();
        if((Req != null) && __isset.req)
        {
          tmp387.Req = (TSInsertTabletReq)this.Req.DeepCopy();
        }
        tmp387.__isset.req = this.__isset.req;
        return tmp387;
      }

      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 tmp388 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp388++) { 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 insertTabletResult DeepCopy()
      {
        var tmp389 = new insertTabletResult();
        if((Success != null) && __isset.success)
        {
          tmp389.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp389.__isset.success = this.__isset.success;
        return tmp389;
      }

      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 tmp390 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp390++) { 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 insertTabletsArgs DeepCopy()
      {
        var tmp391 = new insertTabletsArgs();
        if((Req != null) && __isset.req)
        {
          tmp391.Req = (TSInsertTabletsReq)this.Req.DeepCopy();
        }
        tmp391.__isset.req = this.__isset.req;
        return tmp391;
      }

      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 tmp392 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp392++) { 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 insertTabletsResult DeepCopy()
      {
        var tmp393 = new insertTabletsResult();
        if((Success != null) && __isset.success)
        {
          tmp393.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp393.__isset.success = this.__isset.success;
        return tmp393;
      }

      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 tmp394 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp394++) { 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 insertRecordsArgs DeepCopy()
      {
        var tmp395 = new insertRecordsArgs();
        if((Req != null) && __isset.req)
        {
          tmp395.Req = (TSInsertRecordsReq)this.Req.DeepCopy();
        }
        tmp395.__isset.req = this.__isset.req;
        return tmp395;
      }

      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 tmp396 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp396++) { 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 insertRecordsResult DeepCopy()
      {
        var tmp397 = new insertRecordsResult();
        if((Success != null) && __isset.success)
        {
          tmp397.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp397.__isset.success = this.__isset.success;
        return tmp397;
      }

      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 tmp398 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp398++) { 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 insertRecordsOfOneDeviceArgs DeepCopy()
      {
        var tmp399 = new insertRecordsOfOneDeviceArgs();
        if((Req != null) && __isset.req)
        {
          tmp399.Req = (TSInsertRecordsOfOneDeviceReq)this.Req.DeepCopy();
        }
        tmp399.__isset.req = this.__isset.req;
        return tmp399;
      }

      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 tmp400 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp400++) { 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 insertRecordsOfOneDeviceResult DeepCopy()
      {
        var tmp401 = new insertRecordsOfOneDeviceResult();
        if((Success != null) && __isset.success)
        {
          tmp401.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp401.__isset.success = this.__isset.success;
        return tmp401;
      }

      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 tmp402 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp402++) { 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 insertStringRecordsArgs DeepCopy()
      {
        var tmp403 = new insertStringRecordsArgs();
        if((Req != null) && __isset.req)
        {
          tmp403.Req = (TSInsertStringRecordsReq)this.Req.DeepCopy();
        }
        tmp403.__isset.req = this.__isset.req;
        return tmp403;
      }

      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 tmp404 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp404++) { 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 insertStringRecordsResult DeepCopy()
      {
        var tmp405 = new insertStringRecordsResult();
        if((Success != null) && __isset.success)
        {
          tmp405.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp405.__isset.success = this.__isset.success;
        return tmp405;
      }

      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 tmp406 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp406++) { 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 testInsertTabletArgs DeepCopy()
      {
        var tmp407 = new testInsertTabletArgs();
        if((Req != null) && __isset.req)
        {
          tmp407.Req = (TSInsertTabletReq)this.Req.DeepCopy();
        }
        tmp407.__isset.req = this.__isset.req;
        return tmp407;
      }

      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 tmp408 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp408++) { 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 testInsertTabletResult DeepCopy()
      {
        var tmp409 = new testInsertTabletResult();
        if((Success != null) && __isset.success)
        {
          tmp409.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp409.__isset.success = this.__isset.success;
        return tmp409;
      }

      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 tmp410 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp410++) { 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 testInsertTabletsArgs DeepCopy()
      {
        var tmp411 = new testInsertTabletsArgs();
        if((Req != null) && __isset.req)
        {
          tmp411.Req = (TSInsertTabletsReq)this.Req.DeepCopy();
        }
        tmp411.__isset.req = this.__isset.req;
        return tmp411;
      }

      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 tmp412 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp412++) { 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 testInsertTabletsResult DeepCopy()
      {
        var tmp413 = new testInsertTabletsResult();
        if((Success != null) && __isset.success)
        {
          tmp413.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp413.__isset.success = this.__isset.success;
        return tmp413;
      }

      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 tmp414 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp414++) { 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 testInsertRecordArgs DeepCopy()
      {
        var tmp415 = new testInsertRecordArgs();
        if((Req != null) && __isset.req)
        {
          tmp415.Req = (TSInsertRecordReq)this.Req.DeepCopy();
        }
        tmp415.__isset.req = this.__isset.req;
        return tmp415;
      }

      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 tmp416 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp416++) { 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 testInsertRecordResult DeepCopy()
      {
        var tmp417 = new testInsertRecordResult();
        if((Success != null) && __isset.success)
        {
          tmp417.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp417.__isset.success = this.__isset.success;
        return tmp417;
      }

      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 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 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 testInsertStringRecordArgs DeepCopy()
      {
        var tmp419 = new testInsertStringRecordArgs();
        if((Req != null) && __isset.req)
        {
          tmp419.Req = (TSInsertStringRecordReq)this.Req.DeepCopy();
        }
        tmp419.__isset.req = this.__isset.req;
        return tmp419;
      }

      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 tmp420 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp420++) { 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 testInsertStringRecordResult DeepCopy()
      {
        var tmp421 = new testInsertStringRecordResult();
        if((Success != null) && __isset.success)
        {
          tmp421.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp421.__isset.success = this.__isset.success;
        return tmp421;
      }

      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 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 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 testInsertRecordsArgs DeepCopy()
      {
        var tmp423 = new testInsertRecordsArgs();
        if((Req != null) && __isset.req)
        {
          tmp423.Req = (TSInsertRecordsReq)this.Req.DeepCopy();
        }
        tmp423.__isset.req = this.__isset.req;
        return tmp423;
      }

      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 tmp424 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp424++) { 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 testInsertRecordsResult DeepCopy()
      {
        var tmp425 = new testInsertRecordsResult();
        if((Success != null) && __isset.success)
        {
          tmp425.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp425.__isset.success = this.__isset.success;
        return tmp425;
      }

      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 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 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 testInsertRecordsOfOneDeviceArgs DeepCopy()
      {
        var tmp427 = new testInsertRecordsOfOneDeviceArgs();
        if((Req != null) && __isset.req)
        {
          tmp427.Req = (TSInsertRecordsOfOneDeviceReq)this.Req.DeepCopy();
        }
        tmp427.__isset.req = this.__isset.req;
        return tmp427;
      }

      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 tmp428 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp428++) { 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 testInsertRecordsOfOneDeviceResult DeepCopy()
      {
        var tmp429 = new testInsertRecordsOfOneDeviceResult();
        if((Success != null) && __isset.success)
        {
          tmp429.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp429.__isset.success = this.__isset.success;
        return tmp429;
      }

      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 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 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 testInsertStringRecordsArgs DeepCopy()
      {
        var tmp431 = new testInsertStringRecordsArgs();
        if((Req != null) && __isset.req)
        {
          tmp431.Req = (TSInsertStringRecordsReq)this.Req.DeepCopy();
        }
        tmp431.__isset.req = this.__isset.req;
        return tmp431;
      }

      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 tmp432 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp432++) { 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 testInsertStringRecordsResult DeepCopy()
      {
        var tmp433 = new testInsertStringRecordsResult();
        if((Success != null) && __isset.success)
        {
          tmp433.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp433.__isset.success = this.__isset.success;
        return tmp433;
      }

      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 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 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 deleteDataArgs DeepCopy()
      {
        var tmp435 = new deleteDataArgs();
        if((Req != null) && __isset.req)
        {
          tmp435.Req = (TSDeleteDataReq)this.Req.DeepCopy();
        }
        tmp435.__isset.req = this.__isset.req;
        return tmp435;
      }

      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 tmp436 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp436++) { 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 deleteDataResult DeepCopy()
      {
        var tmp437 = new deleteDataResult();
        if((Success != null) && __isset.success)
        {
          tmp437.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp437.__isset.success = this.__isset.success;
        return tmp437;
      }

      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 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 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 executeRawDataQueryArgs DeepCopy()
      {
        var tmp439 = new executeRawDataQueryArgs();
        if((Req != null) && __isset.req)
        {
          tmp439.Req = (TSRawDataQueryReq)this.Req.DeepCopy();
        }
        tmp439.__isset.req = this.__isset.req;
        return tmp439;
      }

      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 tmp440 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp440++) { 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 executeRawDataQueryResult DeepCopy()
      {
        var tmp441 = new executeRawDataQueryResult();
        if((Success != null) && __isset.success)
        {
          tmp441.Success = (TSExecuteStatementResp)this.Success.DeepCopy();
        }
        tmp441.__isset.success = this.__isset.success;
        return tmp441;
      }

      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 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 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 requestStatementIdArgs DeepCopy()
      {
        var tmp443 = new requestStatementIdArgs();
        if(__isset.sessionId)
        {
          tmp443.SessionId = this.SessionId;
        }
        tmp443.__isset.sessionId = this.__isset.sessionId;
        return tmp443;
      }

      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 tmp444 = 0;
        if(__isset.sessionId)
        {
          if(0 < tmp444++) { 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 requestStatementIdResult DeepCopy()
      {
        var tmp445 = new requestStatementIdResult();
        if(__isset.success)
        {
          tmp445.Success = this.Success;
        }
        tmp445.__isset.success = this.__isset.success;
        return tmp445;
      }

      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 tmp446 = 0;
        if(__isset.success)
        {
          if(0 < tmp446++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }

  }

}