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

/**
 * Autogenerated by Thrift Compiler (0.14.2)
 *
 * 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> createAlignedTimeseriesAsync(TSCreateAlignedTimeseriesReq req, CancellationToken cancellationToken = default);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  }


  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> createAlignedTimeseriesAsync(TSCreateAlignedTimeseriesReq req, CancellationToken cancellationToken = default)
    {
      await OutputProtocol.WriteMessageBeginAsync(new TMessage("createAlignedTimeseries", TMessageType.Call, SeqId), cancellationToken);
      
      var args = new InternalStructs.createAlignedTimeseriesArgs() {
        Req = req,
      };
      
      await args.WriteAsync(OutputProtocol, cancellationToken);
      await OutputProtocol.WriteMessageEndAsync(cancellationToken);
      await OutputProtocol.Transport.FlushAsync(cancellationToken);
      
      var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
      if (msg.Type == TMessageType.Exception)
      {
        var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        throw x;
      }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  }

  public 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_["createAlignedTimeseries"] = createAlignedTimeseries_ProcessAsync;
      processMap_["createMultiTimeseries"] = createMultiTimeseries_ProcessAsync;
      processMap_["deleteTimeseries"] = deleteTimeseries_ProcessAsync;
      processMap_["deleteStorageGroups"] = deleteStorageGroups_ProcessAsync;
      processMap_["insertRecord"] = insertRecord_ProcessAsync;
      processMap_["insertStringRecord"] = insertStringRecord_ProcessAsync;
      processMap_["insertTablet"] = insertTablet_ProcessAsync;
      processMap_["insertTablets"] = insertTablets_ProcessAsync;
      processMap_["insertRecords"] = insertRecords_ProcessAsync;
      processMap_["insertRecordsOfOneDevice"] = insertRecordsOfOneDevice_ProcessAsync;
      processMap_["insertStringRecordsOfOneDevice"] = insertStringRecordsOfOneDevice_ProcessAsync;
      processMap_["insertStringRecords"] = insertStringRecords_ProcessAsync;
      processMap_["testInsertTablet"] = testInsertTablet_ProcessAsync;
      processMap_["testInsertTablets"] = testInsertTablets_ProcessAsync;
      processMap_["testInsertRecord"] = testInsertRecord_ProcessAsync;
      processMap_["testInsertStringRecord"] = testInsertStringRecord_ProcessAsync;
      processMap_["testInsertRecords"] = testInsertRecords_ProcessAsync;
      processMap_["testInsertRecordsOfOneDevice"] = testInsertRecordsOfOneDevice_ProcessAsync;
      processMap_["testInsertStringRecords"] = testInsertStringRecords_ProcessAsync;
      processMap_["deleteData"] = deleteData_ProcessAsync;
      processMap_["executeRawDataQuery"] = executeRawDataQuery_ProcessAsync;
      processMap_["executeLastDataQuery"] = executeLastDataQuery_ProcessAsync;
      processMap_["requestStatementId"] = requestStatementId_ProcessAsync;
      processMap_["createSchemaTemplate"] = createSchemaTemplate_ProcessAsync;
      processMap_["appendSchemaTemplate"] = appendSchemaTemplate_ProcessAsync;
      processMap_["pruneSchemaTemplate"] = pruneSchemaTemplate_ProcessAsync;
      processMap_["querySchemaTemplate"] = querySchemaTemplate_ProcessAsync;
      processMap_["setSchemaTemplate"] = setSchemaTemplate_ProcessAsync;
      processMap_["unsetSchemaTemplate"] = unsetSchemaTemplate_ProcessAsync;
      processMap_["dropSchemaTemplate"] = dropSchemaTemplate_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 createAlignedTimeseries_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
    {
      var args = new InternalStructs.createAlignedTimeseriesArgs();
      await args.ReadAsync(iprot, cancellationToken);
      await iprot.ReadMessageEndAsync(cancellationToken);
      var result = new InternalStructs.createAlignedTimeseriesResult();
      try
      {
        result.Success = await _iAsync.createAlignedTimeseriesAsync(args.Req, cancellationToken);
        await oprot.WriteMessageBeginAsync(new TMessage("createAlignedTimeseries", TMessageType.Reply, seqid), cancellationToken); 
        await result.WriteAsync(oprot, cancellationToken);
      }
      catch (TTransportException)
      {
        throw;
      }
      catch (Exception ex)
      {
        var sErr = $"Error occurred in {GetType().FullName}: {ex.Message}";
        if(_logger != null)
          _logger.LogError(ex, sErr);
        else
          Console.Error.WriteLine(sErr);
        var x = new TApplicationException(TApplicationException.ExceptionType.InternalError," Internal error.");
        await oprot.WriteMessageBeginAsync(new TMessage("createAlignedTimeseries", TMessageType.Exception, seqid), cancellationToken);
        await x.WriteAsync(oprot, cancellationToken);
      }
      await oprot.WriteMessageEndAsync(cancellationToken);
      await oprot.Transport.FlushAsync(cancellationToken);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  }

  public 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 tmp421 = new openSessionArgs();
        if((Req != null) && __isset.req)
        {
          tmp421.Req = (TSOpenSessionReq)this.Req.DeepCopy();
        }
        tmp421.__isset.req = this.__isset.req;
        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 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 tmp422 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp422++) { 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 tmp423 = new openSessionResult();
        if((Success != null) && __isset.success)
        {
          tmp423.Success = (TSOpenSessionResp)this.Success.DeepCopy();
        }
        tmp423.__isset.success = this.__isset.success;
        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 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 tmp424 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp424++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class 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 tmp425 = new closeSessionArgs();
        if((Req != null) && __isset.req)
        {
          tmp425.Req = (TSCloseSessionReq)this.Req.DeepCopy();
        }
        tmp425.__isset.req = this.__isset.req;
        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 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 tmp426 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp426++) { 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 tmp427 = new closeSessionResult();
        if((Success != null) && __isset.success)
        {
          tmp427.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp427.__isset.success = this.__isset.success;
        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 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 tmp428 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp428++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class 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 tmp429 = new executeStatementArgs();
        if((Req != null) && __isset.req)
        {
          tmp429.Req = (TSExecuteStatementReq)this.Req.DeepCopy();
        }
        tmp429.__isset.req = this.__isset.req;
        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 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 tmp430 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp430++) { 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 tmp431 = new executeStatementResult();
        if((Success != null) && __isset.success)
        {
          tmp431.Success = (TSExecuteStatementResp)this.Success.DeepCopy();
        }
        tmp431.__isset.success = this.__isset.success;
        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 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 tmp432 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp432++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class 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 tmp433 = new executeBatchStatementArgs();
        if((Req != null) && __isset.req)
        {
          tmp433.Req = (TSExecuteBatchStatementReq)this.Req.DeepCopy();
        }
        tmp433.__isset.req = this.__isset.req;
        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 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 tmp434 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp434++) { 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 tmp435 = new executeBatchStatementResult();
        if((Success != null) && __isset.success)
        {
          tmp435.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp435.__isset.success = this.__isset.success;
        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 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 tmp436 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp436++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class 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 tmp437 = new executeQueryStatementArgs();
        if((Req != null) && __isset.req)
        {
          tmp437.Req = (TSExecuteStatementReq)this.Req.DeepCopy();
        }
        tmp437.__isset.req = this.__isset.req;
        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 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 tmp438 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp438++) { 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 tmp439 = new executeQueryStatementResult();
        if((Success != null) && __isset.success)
        {
          tmp439.Success = (TSExecuteStatementResp)this.Success.DeepCopy();
        }
        tmp439.__isset.success = this.__isset.success;
        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 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 tmp440 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp440++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class 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 tmp441 = new executeUpdateStatementArgs();
        if((Req != null) && __isset.req)
        {
          tmp441.Req = (TSExecuteStatementReq)this.Req.DeepCopy();
        }
        tmp441.__isset.req = this.__isset.req;
        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 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 tmp442 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp442++) { 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 tmp443 = new executeUpdateStatementResult();
        if((Success != null) && __isset.success)
        {
          tmp443.Success = (TSExecuteStatementResp)this.Success.DeepCopy();
        }
        tmp443.__isset.success = this.__isset.success;
        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 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 tmp444 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp444++) { sb.Append(", "); }
          sb.Append("Success: ");
          Success.ToString(sb);
        }
        sb.Append(')');
        return sb.ToString();
      }
    }


    public partial class 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 tmp445 = new fetchResultsArgs();
        if((Req != null) && __isset.req)
        {
          tmp445.Req = (TSFetchResultsReq)this.Req.DeepCopy();
        }
        tmp445.__isset.req = this.__isset.req;
        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 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 tmp446 = 0;
        if((Req != null) && __isset.req)
        {
          if(0 < tmp446++) { 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 tmp447 = new fetchResultsResult();
        if((Success != null) && __isset.success)
        {
          tmp447.Success = (TSFetchResultsResp)this.Success.DeepCopy();
        }
        tmp447.__isset.success = this.__isset.success;
        return tmp447;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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

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


    public partial class fetchMetadataArgs : TBase
    {
      private TSFetchMetadataReq _req;

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


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

      public fetchMetadataArgs()
      {
      }

      public fetchMetadataArgs DeepCopy()
      {
        var tmp449 = new fetchMetadataArgs();
        if((Req != null) && __isset.req)
        {
          tmp449.Req = (TSFetchMetadataReq)this.Req.DeepCopy();
        }
        tmp449.__isset.req = this.__isset.req;
        return tmp449;
      }

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

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


    public partial class 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 tmp453 = new cancelOperationArgs();
        if((Req != null) && __isset.req)
        {
          tmp453.Req = (TSCancelOperationReq)this.Req.DeepCopy();
        }
        tmp453.__isset.req = this.__isset.req;
        return tmp453;
      }

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

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


    public partial class 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 tmp457 = new closeOperationArgs();
        if((Req != null) && __isset.req)
        {
          tmp457.Req = (TSCloseOperationReq)this.Req.DeepCopy();
        }
        tmp457.__isset.req = this.__isset.req;
        return tmp457;
      }

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

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


    public partial class 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 tmp461 = new getTimeZoneArgs();
        if(__isset.sessionId)
        {
          tmp461.SessionId = this.SessionId;
        }
        tmp461.__isset.sessionId = this.__isset.sessionId;
        return tmp461;
      }

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

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


    public partial class 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 tmp465 = new setTimeZoneArgs();
        if((Req != null) && __isset.req)
        {
          tmp465.Req = (TSSetTimeZoneReq)this.Req.DeepCopy();
        }
        tmp465.__isset.req = this.__isset.req;
        return tmp465;
      }

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

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


    public partial class getPropertiesArgs : TBase
    {

      public getPropertiesArgs()
      {
      }

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

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

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

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

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

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

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


    public partial class createAlignedTimeseriesArgs : TBase
    {
      private TSCreateAlignedTimeseriesReq _req;

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


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

      public createAlignedTimeseriesArgs()
      {
      }

      public createAlignedTimeseriesArgs DeepCopy()
      {
        var tmp481 = new createAlignedTimeseriesArgs();
        if((Req != null) && __isset.req)
        {
          tmp481.Req = (TSCreateAlignedTimeseriesReq)this.Req.DeepCopy();
        }
        tmp481.__isset.req = this.__isset.req;
        return tmp481;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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


    public partial class createAlignedTimeseriesResult : TBase
    {
      private TSStatus _success;

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


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

      public createAlignedTimeseriesResult()
      {
      }

      public createAlignedTimeseriesResult DeepCopy()
      {
        var tmp483 = new createAlignedTimeseriesResult();
        if((Success != null) && __isset.success)
        {
          tmp483.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp483.__isset.success = this.__isset.success;
        return tmp483;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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

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


    public partial class 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 tmp485 = new createMultiTimeseriesArgs();
        if((Req != null) && __isset.req)
        {
          tmp485.Req = (TSCreateMultiTimeseriesReq)this.Req.DeepCopy();
        }
        tmp485.__isset.req = this.__isset.req;
        return tmp485;
      }

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

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


    public partial class 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 tmp489 = new deleteTimeseriesArgs();
        if(__isset.sessionId)
        {
          tmp489.SessionId = this.SessionId;
        }
        tmp489.__isset.sessionId = this.__isset.sessionId;
        if((Path != null) && __isset.path)
        {
          tmp489.Path = this.Path.DeepCopy();
        }
        tmp489.__isset.path = this.__isset.path;
        return tmp489;
      }

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

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


    public partial class 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 tmp497 = new deleteStorageGroupsArgs();
        if(__isset.sessionId)
        {
          tmp497.SessionId = this.SessionId;
        }
        tmp497.__isset.sessionId = this.__isset.sessionId;
        if((StorageGroup != null) && __isset.storageGroup)
        {
          tmp497.StorageGroup = this.StorageGroup.DeepCopy();
        }
        tmp497.__isset.storageGroup = this.__isset.storageGroup;
        return tmp497;
      }

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

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


    public partial class 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 tmp505 = new insertRecordArgs();
        if((Req != null) && __isset.req)
        {
          tmp505.Req = (TSInsertRecordReq)this.Req.DeepCopy();
        }
        tmp505.__isset.req = this.__isset.req;
        return tmp505;
      }

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

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


    public partial class 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 tmp509 = new insertStringRecordArgs();
        if((Req != null) && __isset.req)
        {
          tmp509.Req = (TSInsertStringRecordReq)this.Req.DeepCopy();
        }
        tmp509.__isset.req = this.__isset.req;
        return tmp509;
      }

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

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


    public partial class 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 tmp513 = new insertTabletArgs();
        if((Req != null) && __isset.req)
        {
          tmp513.Req = (TSInsertTabletReq)this.Req.DeepCopy();
        }
        tmp513.__isset.req = this.__isset.req;
        return tmp513;
      }

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

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


    public partial class 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 tmp517 = new insertTabletsArgs();
        if((Req != null) && __isset.req)
        {
          tmp517.Req = (TSInsertTabletsReq)this.Req.DeepCopy();
        }
        tmp517.__isset.req = this.__isset.req;
        return tmp517;
      }

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

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

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

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


    public partial class 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 tmp525 = new insertRecordsOfOneDeviceArgs();
        if((Req != null) && __isset.req)
        {
          tmp525.Req = (TSInsertRecordsOfOneDeviceReq)this.Req.DeepCopy();
        }
        tmp525.__isset.req = this.__isset.req;
        return tmp525;
      }

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

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


    public partial class insertStringRecordsOfOneDeviceArgs : TBase
    {
      private TSInsertStringRecordsOfOneDeviceReq _req;

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


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

      public insertStringRecordsOfOneDeviceArgs()
      {
      }

      public insertStringRecordsOfOneDeviceArgs DeepCopy()
      {
        var tmp529 = new insertStringRecordsOfOneDeviceArgs();
        if((Req != null) && __isset.req)
        {
          tmp529.Req = (TSInsertStringRecordsOfOneDeviceReq)this.Req.DeepCopy();
        }
        tmp529.__isset.req = this.__isset.req;
        return tmp529;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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


    public partial class insertStringRecordsOfOneDeviceResult : TBase
    {
      private TSStatus _success;

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


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

      public insertStringRecordsOfOneDeviceResult()
      {
      }

      public insertStringRecordsOfOneDeviceResult DeepCopy()
      {
        var tmp531 = new insertStringRecordsOfOneDeviceResult();
        if((Success != null) && __isset.success)
        {
          tmp531.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp531.__isset.success = this.__isset.success;
        return tmp531;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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

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


    public partial class 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 tmp533 = new insertStringRecordsArgs();
        if((Req != null) && __isset.req)
        {
          tmp533.Req = (TSInsertStringRecordsReq)this.Req.DeepCopy();
        }
        tmp533.__isset.req = this.__isset.req;
        return tmp533;
      }

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

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


    public partial class 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 tmp537 = new testInsertTabletArgs();
        if((Req != null) && __isset.req)
        {
          tmp537.Req = (TSInsertTabletReq)this.Req.DeepCopy();
        }
        tmp537.__isset.req = this.__isset.req;
        return tmp537;
      }

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

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


    public partial class 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 tmp541 = new testInsertTabletsArgs();
        if((Req != null) && __isset.req)
        {
          tmp541.Req = (TSInsertTabletsReq)this.Req.DeepCopy();
        }
        tmp541.__isset.req = this.__isset.req;
        return tmp541;
      }

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

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


    public partial class 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 tmp545 = new testInsertRecordArgs();
        if((Req != null) && __isset.req)
        {
          tmp545.Req = (TSInsertRecordReq)this.Req.DeepCopy();
        }
        tmp545.__isset.req = this.__isset.req;
        return tmp545;
      }

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

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


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

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

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


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

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

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

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

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

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

      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 tmp564 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp564++) { 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 tmp565 = new deleteDataArgs();
        if((Req != null) && __isset.req)
        {
          tmp565.Req = (TSDeleteDataReq)this.Req.DeepCopy();
        }
        tmp565.__isset.req = this.__isset.req;
        return tmp565;
      }

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

      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 tmp568 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp568++) { 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 tmp569 = new executeRawDataQueryArgs();
        if((Req != null) && __isset.req)
        {
          tmp569.Req = (TSRawDataQueryReq)this.Req.DeepCopy();
        }
        tmp569.__isset.req = this.__isset.req;
        return tmp569;
      }

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

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


    public partial class executeLastDataQueryArgs : TBase
    {
      private TSLastDataQueryReq _req;

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


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

      public executeLastDataQueryArgs()
      {
      }

      public executeLastDataQueryArgs DeepCopy()
      {
        var tmp573 = new executeLastDataQueryArgs();
        if((Req != null) && __isset.req)
        {
          tmp573.Req = (TSLastDataQueryReq)this.Req.DeepCopy();
        }
        tmp573.__isset.req = this.__isset.req;
        return tmp573;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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


    public partial class executeLastDataQueryResult : TBase
    {
      private TSExecuteStatementResp _success;

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


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

      public executeLastDataQueryResult()
      {
      }

      public executeLastDataQueryResult DeepCopy()
      {
        var tmp575 = new executeLastDataQueryResult();
        if((Success != null) && __isset.success)
        {
          tmp575.Success = (TSExecuteStatementResp)this.Success.DeepCopy();
        }
        tmp575.__isset.success = this.__isset.success;
        return tmp575;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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

      public override string ToString()
      {
        var sb = new StringBuilder("executeLastDataQuery_result(");
        int tmp576 = 0;
        if((Success != null) && __isset.success)
        {
          if(0 < tmp576++) { 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 tmp577 = new requestStatementIdArgs();
        if(__isset.sessionId)
        {
          tmp577.SessionId = this.SessionId;
        }
        tmp577.__isset.sessionId = this.__isset.sessionId;
        return tmp577;
      }

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

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


    public partial class createSchemaTemplateArgs : TBase
    {
      private TSCreateSchemaTemplateReq _req;

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


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

      public createSchemaTemplateArgs()
      {
      }

      public createSchemaTemplateArgs DeepCopy()
      {
        var tmp581 = new createSchemaTemplateArgs();
        if((Req != null) && __isset.req)
        {
          tmp581.Req = (TSCreateSchemaTemplateReq)this.Req.DeepCopy();
        }
        tmp581.__isset.req = this.__isset.req;
        return tmp581;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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


    public partial class createSchemaTemplateResult : TBase
    {
      private TSStatus _success;

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


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

      public createSchemaTemplateResult()
      {
      }

      public createSchemaTemplateResult DeepCopy()
      {
        var tmp583 = new createSchemaTemplateResult();
        if((Success != null) && __isset.success)
        {
          tmp583.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp583.__isset.success = this.__isset.success;
        return tmp583;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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

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


    public partial class appendSchemaTemplateArgs : TBase
    {
      private TSAppendSchemaTemplateReq _req;

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


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

      public appendSchemaTemplateArgs()
      {
      }

      public appendSchemaTemplateArgs DeepCopy()
      {
        var tmp585 = new appendSchemaTemplateArgs();
        if((Req != null) && __isset.req)
        {
          tmp585.Req = (TSAppendSchemaTemplateReq)this.Req.DeepCopy();
        }
        tmp585.__isset.req = this.__isset.req;
        return tmp585;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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


    public partial class appendSchemaTemplateResult : TBase
    {
      private TSStatus _success;

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


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

      public appendSchemaTemplateResult()
      {
      }

      public appendSchemaTemplateResult DeepCopy()
      {
        var tmp587 = new appendSchemaTemplateResult();
        if((Success != null) && __isset.success)
        {
          tmp587.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp587.__isset.success = this.__isset.success;
        return tmp587;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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

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


    public partial class pruneSchemaTemplateArgs : TBase
    {
      private TSPruneSchemaTemplateReq _req;

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


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

      public pruneSchemaTemplateArgs()
      {
      }

      public pruneSchemaTemplateArgs DeepCopy()
      {
        var tmp589 = new pruneSchemaTemplateArgs();
        if((Req != null) && __isset.req)
        {
          tmp589.Req = (TSPruneSchemaTemplateReq)this.Req.DeepCopy();
        }
        tmp589.__isset.req = this.__isset.req;
        return tmp589;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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


    public partial class pruneSchemaTemplateResult : TBase
    {
      private TSStatus _success;

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


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

      public pruneSchemaTemplateResult()
      {
      }

      public pruneSchemaTemplateResult DeepCopy()
      {
        var tmp591 = new pruneSchemaTemplateResult();
        if((Success != null) && __isset.success)
        {
          tmp591.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp591.__isset.success = this.__isset.success;
        return tmp591;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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

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


    public partial class querySchemaTemplateArgs : TBase
    {
      private TSQueryTemplateReq _req;

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


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

      public querySchemaTemplateArgs()
      {
      }

      public querySchemaTemplateArgs DeepCopy()
      {
        var tmp593 = new querySchemaTemplateArgs();
        if((Req != null) && __isset.req)
        {
          tmp593.Req = (TSQueryTemplateReq)this.Req.DeepCopy();
        }
        tmp593.__isset.req = this.__isset.req;
        return tmp593;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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


    public partial class querySchemaTemplateResult : TBase
    {
      private TSQueryTemplateResp _success;

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


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

      public querySchemaTemplateResult()
      {
      }

      public querySchemaTemplateResult DeepCopy()
      {
        var tmp595 = new querySchemaTemplateResult();
        if((Success != null) && __isset.success)
        {
          tmp595.Success = (TSQueryTemplateResp)this.Success.DeepCopy();
        }
        tmp595.__isset.success = this.__isset.success;
        return tmp595;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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

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


    public partial class setSchemaTemplateArgs : TBase
    {
      private TSSetSchemaTemplateReq _req;

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


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

      public setSchemaTemplateArgs()
      {
      }

      public setSchemaTemplateArgs DeepCopy()
      {
        var tmp597 = new setSchemaTemplateArgs();
        if((Req != null) && __isset.req)
        {
          tmp597.Req = (TSSetSchemaTemplateReq)this.Req.DeepCopy();
        }
        tmp597.__isset.req = this.__isset.req;
        return tmp597;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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


    public partial class setSchemaTemplateResult : TBase
    {
      private TSStatus _success;

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


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

      public setSchemaTemplateResult()
      {
      }

      public setSchemaTemplateResult DeepCopy()
      {
        var tmp599 = new setSchemaTemplateResult();
        if((Success != null) && __isset.success)
        {
          tmp599.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp599.__isset.success = this.__isset.success;
        return tmp599;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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

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


    public partial class unsetSchemaTemplateArgs : TBase
    {
      private TSUnsetSchemaTemplateReq _req;

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


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

      public unsetSchemaTemplateArgs()
      {
      }

      public unsetSchemaTemplateArgs DeepCopy()
      {
        var tmp601 = new unsetSchemaTemplateArgs();
        if((Req != null) && __isset.req)
        {
          tmp601.Req = (TSUnsetSchemaTemplateReq)this.Req.DeepCopy();
        }
        tmp601.__isset.req = this.__isset.req;
        return tmp601;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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


    public partial class unsetSchemaTemplateResult : TBase
    {
      private TSStatus _success;

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


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

      public unsetSchemaTemplateResult()
      {
      }

      public unsetSchemaTemplateResult DeepCopy()
      {
        var tmp603 = new unsetSchemaTemplateResult();
        if((Success != null) && __isset.success)
        {
          tmp603.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp603.__isset.success = this.__isset.success;
        return tmp603;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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

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


    public partial class dropSchemaTemplateArgs : TBase
    {
      private TSDropSchemaTemplateReq _req;

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


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

      public dropSchemaTemplateArgs()
      {
      }

      public dropSchemaTemplateArgs DeepCopy()
      {
        var tmp605 = new dropSchemaTemplateArgs();
        if((Req != null) && __isset.req)
        {
          tmp605.Req = (TSDropSchemaTemplateReq)this.Req.DeepCopy();
        }
        tmp605.__isset.req = this.__isset.req;
        return tmp605;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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


    public partial class dropSchemaTemplateResult : TBase
    {
      private TSStatus _success;

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


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

      public dropSchemaTemplateResult()
      {
      }

      public dropSchemaTemplateResult DeepCopy()
      {
        var tmp607 = new dropSchemaTemplateResult();
        if((Success != null) && __isset.success)
        {
          tmp607.Success = (TSStatus)this.Success.DeepCopy();
        }
        tmp607.__isset.success = this.__isset.success;
        return tmp607;
      }

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

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

            await iprot.ReadFieldEndAsync(cancellationToken);
          }

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

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

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

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

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

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

  }

}