/**
 * Autogenerated by Thrift Compiler (0.14.0)
 *
 * 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 System.ServiceModel;
using System.Runtime.Serialization;

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

namespace Apache.Cassandra.Test
{
  public partial class Cassandra
  {
    [ServiceContract(Namespace="")]
    public interface IAsync
    {
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.AuthenticationExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.AuthorizationExceptionFault))]
      global::System.Threading.Tasks.Task loginAsync(global::Apache.Cassandra.Test.AuthenticationRequest auth_request, CancellationToken cancellationToken = default);

      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      global::System.Threading.Tasks.Task set_keyspaceAsync(string keyspace, CancellationToken cancellationToken = default);

      /// <summary>
      /// Get the Column or SuperColumn at the given column_path. If no value is present, NotFoundException is thrown. (This is
      /// the only method that can throw an exception under non-failure conditions.)
      /// </summary>
      /// <param name="key"></param>
      /// <param name="column_path"></param>
      /// <param name="consistency_level"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.NotFoundExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task<global::Apache.Cassandra.Test.ColumnOrSuperColumn> @getAsync(byte[] key, global::Apache.Cassandra.Test.ColumnPath column_path, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default);

      /// <summary>
      /// Get the group of columns contained by column_parent (either a ColumnFamily name or a ColumnFamily/SuperColumn name
      /// pair) specified by the given SlicePredicate. If no matching values are found, an empty list is returned.
      /// </summary>
      /// <param name="key"></param>
      /// <param name="column_parent"></param>
      /// <param name="predicate"></param>
      /// <param name="consistency_level"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task<List<global::Apache.Cassandra.Test.ColumnOrSuperColumn>> get_sliceAsync(byte[] key, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default);

      /// <summary>
      /// returns the number of columns matching <code>predicate</code> for a particular <code>key</code>,
      /// <code>ColumnFamily</code> and optionally <code>SuperColumn</code>.
      /// </summary>
      /// <param name="key"></param>
      /// <param name="column_parent"></param>
      /// <param name="predicate"></param>
      /// <param name="consistency_level"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task<int> get_countAsync(byte[] key, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default);

      /// <summary>
      /// Performs a get_slice for column_parent and predicate for the given keys in parallel.
      /// </summary>
      /// <param name="keys"></param>
      /// <param name="column_parent"></param>
      /// <param name="predicate"></param>
      /// <param name="consistency_level"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task<Dictionary<byte[], List<global::Apache.Cassandra.Test.ColumnOrSuperColumn>>> multiget_sliceAsync(List<byte[]> keys, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default);

      /// <summary>
      /// Perform a get_count in parallel on the given list<binary> keys. The return value maps keys to the count found.
      /// </summary>
      /// <param name="keys"></param>
      /// <param name="column_parent"></param>
      /// <param name="predicate"></param>
      /// <param name="consistency_level"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task<Dictionary<byte[], int>> multiget_countAsync(List<byte[]> keys, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default);

      /// <summary>
      /// returns a subset of columns for a contiguous range of keys.
      /// </summary>
      /// <param name="column_parent"></param>
      /// <param name="predicate"></param>
      /// <param name="range"></param>
      /// <param name="consistency_level"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task<List<global::Apache.Cassandra.Test.KeySlice>> get_range_slicesAsync(global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.KeyRange range, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default);

      /// <summary>
      /// Returns the subset of columns specified in SlicePredicate for the rows matching the IndexClause
      /// </summary>
      /// <param name="column_parent"></param>
      /// <param name="index_clause"></param>
      /// <param name="column_predicate"></param>
      /// <param name="consistency_level"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task<List<global::Apache.Cassandra.Test.KeySlice>> get_indexed_slicesAsync(global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.IndexClause index_clause, global::Apache.Cassandra.Test.SlicePredicate column_predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default);

      /// <summary>
      /// Insert a Column at the given column_parent.column_family and optional column_parent.super_column.
      /// </summary>
      /// <param name="key"></param>
      /// <param name="column_parent"></param>
      /// <param name="column"></param>
      /// <param name="consistency_level"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task insertAsync(byte[] key, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.Column column, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default);

      /// <summary>
      /// Increment or decrement a counter.
      /// </summary>
      /// <param name="key"></param>
      /// <param name="column_parent"></param>
      /// <param name="column"></param>
      /// <param name="consistency_level"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task @addAsync(byte[] key, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.CounterColumn column, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default);

      /// <summary>
      /// Remove data from the row specified by key at the granularity specified by column_path, and the given timestamp. Note
      /// that all the values in column_path besides column_path.column_family are truly optional: you can remove the entire
      /// row by just specifying the ColumnFamily, or you can remove a SuperColumn or a single Column by specifying those levels too.
      /// </summary>
      /// <param name="key"></param>
      /// <param name="column_path"></param>
      /// <param name="timestamp"></param>
      /// <param name="consistency_level"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task @removeAsync(byte[] key, global::Apache.Cassandra.Test.ColumnPath column_path, long timestamp, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default);

      /// <summary>
      /// Remove a counter at the specified location.
      /// Note that counters have limited support for deletes: if you remove a counter, you must wait to issue any following update
      /// until the delete has reached all the nodes and all of them have been fully compacted.
      /// </summary>
      /// <param name="key"></param>
      /// <param name="path"></param>
      /// <param name="consistency_level"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task remove_counterAsync(byte[] key, global::Apache.Cassandra.Test.ColumnPath path, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default);

      /// <summary>
      ///   Mutate many columns or super columns for many row keys. See also: Mutation.
      /// 
      ///   mutation_map maps key to column family to a list of Mutation objects to take place at that scope.
      /// *
      /// </summary>
      /// <param name="mutation_map"></param>
      /// <param name="consistency_level"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task batch_mutateAsync(Dictionary<byte[], Dictionary<string, List<global::Apache.Cassandra.Test.Mutation>>> mutation_map, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default);

      /// <summary>
      /// Truncate will mark and entire column family as deleted.
      /// From the user's perspective a successful call to truncate will result complete data deletion from cfname.
      /// Internally, however, disk space will not be immediatily released, as with all deletes in cassandra, this one
      /// only marks the data as deleted.
      /// The operation succeeds only if all hosts in the cluster at available and will throw an UnavailableException if
      /// some hosts are down.
      /// </summary>
      /// <param name="cfname"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      global::System.Threading.Tasks.Task truncateAsync(string cfname, CancellationToken cancellationToken = default);

      /// <summary>
      /// for each schema version present in the cluster, returns a list of nodes at that version.
      /// hosts that do not respond will be under the key DatabaseDescriptor.INITIAL_VERSION.
      /// the cluster is all on the same version if the size of the map is 1.
      /// </summary>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      global::System.Threading.Tasks.Task<Dictionary<string, List<string>>> describe_schema_versionsAsync(CancellationToken cancellationToken = default);

      /// <summary>
      /// list the defined keyspaces in this cluster
      /// </summary>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      global::System.Threading.Tasks.Task<List<global::Apache.Cassandra.Test.KsDef>> describe_keyspacesAsync(CancellationToken cancellationToken = default);

      /// <summary>
      /// get the cluster name
      /// </summary>
      [OperationContract]
      global::System.Threading.Tasks.Task<string> describe_cluster_nameAsync(CancellationToken cancellationToken = default);

      /// <summary>
      /// get the thrift api version
      /// </summary>
      [OperationContract]
      global::System.Threading.Tasks.Task<string> describe_versionAsync(CancellationToken cancellationToken = default);

      /// <summary>
      /// get the token ring: a map of ranges to host addresses,
      /// represented as a set of TokenRange instead of a map from range
      /// to list of endpoints, because you can't use Thrift structs as
      /// map keys:
      /// https://issues.apache.org/jira/browse/THRIFT-162
      /// 
      /// for the same reason, we can't return a set here, even though
      /// order is neither important nor predictable.
      /// </summary>
      /// <param name="keyspace"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      global::System.Threading.Tasks.Task<List<global::Apache.Cassandra.Test.TokenRange>> describe_ringAsync(string keyspace, CancellationToken cancellationToken = default);

      /// <summary>
      /// returns the partitioner used by this cluster
      /// </summary>
      [OperationContract]
      global::System.Threading.Tasks.Task<string> describe_partitionerAsync(CancellationToken cancellationToken = default);

      /// <summary>
      /// returns the snitch used by this cluster
      /// </summary>
      [OperationContract]
      global::System.Threading.Tasks.Task<string> describe_snitchAsync(CancellationToken cancellationToken = default);

      /// <summary>
      /// describe specified keyspace
      /// </summary>
      /// <param name="keyspace"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.NotFoundExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      global::System.Threading.Tasks.Task<global::Apache.Cassandra.Test.KsDef> describe_keyspaceAsync(string keyspace, CancellationToken cancellationToken = default);

      /// <summary>
      /// experimental API for hadoop/parallel query support.
      /// may change violently and without warning.
      /// 
      /// returns list of token strings such that first subrange is (list[0], list[1]],
      /// next is (list[1], list[2]], etc.
      /// </summary>
      /// <param name="cfName"></param>
      /// <param name="start_token"></param>
      /// <param name="end_token"></param>
      /// <param name="keys_per_split"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      global::System.Threading.Tasks.Task<List<string>> describe_splitsAsync(string cfName, string start_token, string end_token, int keys_per_split, CancellationToken cancellationToken = default);

      /// <summary>
      /// adds a column family. returns the new schema id.
      /// </summary>
      /// <param name="cf_def"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.SchemaDisagreementExceptionFault))]
      global::System.Threading.Tasks.Task<string> system_add_column_familyAsync(global::Apache.Cassandra.Test.CfDef cf_def, CancellationToken cancellationToken = default);

      /// <summary>
      /// drops a column family. returns the new schema id.
      /// </summary>
      /// <param name="column_family"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.SchemaDisagreementExceptionFault))]
      global::System.Threading.Tasks.Task<string> system_drop_column_familyAsync(string column_family, CancellationToken cancellationToken = default);

      /// <summary>
      /// adds a keyspace and any column families that are part of it. returns the new schema id.
      /// </summary>
      /// <param name="ks_def"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.SchemaDisagreementExceptionFault))]
      global::System.Threading.Tasks.Task<string> system_add_keyspaceAsync(global::Apache.Cassandra.Test.KsDef ks_def, CancellationToken cancellationToken = default);

      /// <summary>
      /// drops a keyspace and any column families that are part of it. returns the new schema id.
      /// </summary>
      /// <param name="keyspace"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.SchemaDisagreementExceptionFault))]
      global::System.Threading.Tasks.Task<string> system_drop_keyspaceAsync(string keyspace, CancellationToken cancellationToken = default);

      /// <summary>
      /// updates properties of a keyspace. returns the new schema id.
      /// </summary>
      /// <param name="ks_def"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.SchemaDisagreementExceptionFault))]
      global::System.Threading.Tasks.Task<string> system_update_keyspaceAsync(global::Apache.Cassandra.Test.KsDef ks_def, CancellationToken cancellationToken = default);

      /// <summary>
      /// updates properties of a column family. returns the new schema id.
      /// </summary>
      /// <param name="cf_def"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.SchemaDisagreementExceptionFault))]
      global::System.Threading.Tasks.Task<string> system_update_column_familyAsync(global::Apache.Cassandra.Test.CfDef cf_def, CancellationToken cancellationToken = default);

      /// <summary>
      /// Executes a CQL (Cassandra Query Language) statement and returns a
      /// CqlResult containing the results.
      /// </summary>
      /// <param name="query"></param>
      /// <param name="compression"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.SchemaDisagreementExceptionFault))]
      global::System.Threading.Tasks.Task<global::Apache.Cassandra.Test.CqlResult> execute_cql_queryAsync(byte[] query, global::Apache.Cassandra.Test.Compression compression, CancellationToken cancellationToken = default);

      /// <summary>
      /// Prepare a CQL (Cassandra Query Language) statement by compiling and returning
      /// - the type of CQL statement
      /// - an id token of the compiled CQL stored on the server side.
      /// - a count of the discovered bound markers in the statement
      /// </summary>
      /// <param name="query"></param>
      /// <param name="compression"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      global::System.Threading.Tasks.Task<global::Apache.Cassandra.Test.CqlPreparedResult> prepare_cql_queryAsync(byte[] query, global::Apache.Cassandra.Test.Compression compression, CancellationToken cancellationToken = default);

      /// <summary>
      /// Executes a prepared CQL (Cassandra Query Language) statement by passing an id token and  a list of variables
      /// to bind and returns a CqlResult containing the results.
      /// </summary>
      /// <param name="itemId"></param>
      /// <param name="values"></param>
      [OperationContract]
      [FaultContract(typeof(global::Apache.Cassandra.Test.InvalidRequestExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.UnavailableExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.TimedOutExceptionFault))]
      [FaultContract(typeof(global::Apache.Cassandra.Test.SchemaDisagreementExceptionFault))]
      global::System.Threading.Tasks.Task<global::Apache.Cassandra.Test.CqlResult> execute_prepared_cql_queryAsync(int itemId, List<string> values, 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 loginAsync(global::Apache.Cassandra.Test.AuthenticationRequest auth_request, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("login", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.loginArgs() {
          Auth_request = auth_request,
        };
        
        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.loginResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.authnx)
        {
          throw result.Authnx;
        }
        if (result.__isset.authzx)
        {
          throw result.Authzx;
        }
        return;
      }

      public async global::System.Threading.Tasks.Task set_keyspaceAsync(string keyspace, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("set_keyspace", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.set_keyspaceArgs() {
          Keyspace = keyspace,
        };
        
        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.set_keyspaceResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        return;
      }

      public async global::System.Threading.Tasks.Task<global::Apache.Cassandra.Test.ColumnOrSuperColumn> @getAsync(byte[] key, global::Apache.Cassandra.Test.ColumnPath column_path, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("get", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.getArgs() {
          Key = key,
          Column_path = column_path,
          Consistency_level = consistency_level,
        };
        
        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.getResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.nfe)
        {
          throw result.Nfe;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "get failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<List<global::Apache.Cassandra.Test.ColumnOrSuperColumn>> get_sliceAsync(byte[] key, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("get_slice", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.get_sliceArgs() {
          Key = key,
          Column_parent = column_parent,
          Predicate = predicate,
          Consistency_level = consistency_level,
        };
        
        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.get_sliceResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "get_slice failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<int> get_countAsync(byte[] key, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("get_count", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.get_countArgs() {
          Key = key,
          Column_parent = column_parent,
          Predicate = predicate,
          Consistency_level = consistency_level,
        };
        
        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.get_countResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "get_count failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<Dictionary<byte[], List<global::Apache.Cassandra.Test.ColumnOrSuperColumn>>> multiget_sliceAsync(List<byte[]> keys, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("multiget_slice", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.multiget_sliceArgs() {
          Keys = keys,
          Column_parent = column_parent,
          Predicate = predicate,
          Consistency_level = consistency_level,
        };
        
        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.multiget_sliceResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "multiget_slice failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<Dictionary<byte[], int>> multiget_countAsync(List<byte[]> keys, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("multiget_count", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.multiget_countArgs() {
          Keys = keys,
          Column_parent = column_parent,
          Predicate = predicate,
          Consistency_level = consistency_level,
        };
        
        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.multiget_countResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "multiget_count failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<List<global::Apache.Cassandra.Test.KeySlice>> get_range_slicesAsync(global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.KeyRange range, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("get_range_slices", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.get_range_slicesArgs() {
          Column_parent = column_parent,
          Predicate = predicate,
          Range = range,
          Consistency_level = consistency_level,
        };
        
        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.get_range_slicesResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "get_range_slices failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<List<global::Apache.Cassandra.Test.KeySlice>> get_indexed_slicesAsync(global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.IndexClause index_clause, global::Apache.Cassandra.Test.SlicePredicate column_predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("get_indexed_slices", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.get_indexed_slicesArgs() {
          Column_parent = column_parent,
          Index_clause = index_clause,
          Column_predicate = column_predicate,
          Consistency_level = consistency_level,
        };
        
        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.get_indexed_slicesResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "get_indexed_slices failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task insertAsync(byte[] key, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.Column column, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("insert", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.insertArgs() {
          Key = key,
          Column_parent = column_parent,
          Column = column,
          Consistency_level = consistency_level,
        };
        
        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.insertResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        return;
      }

      public async global::System.Threading.Tasks.Task @addAsync(byte[] key, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.CounterColumn column, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("add", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.addArgs() {
          Key = key,
          Column_parent = column_parent,
          Column = column,
          Consistency_level = consistency_level,
        };
        
        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.addResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        return;
      }

      public async global::System.Threading.Tasks.Task @removeAsync(byte[] key, global::Apache.Cassandra.Test.ColumnPath column_path, long timestamp, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("remove", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.removeArgs() {
          Key = key,
          Column_path = column_path,
          Timestamp = timestamp,
          Consistency_level = consistency_level,
        };
        
        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.removeResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        return;
      }

      public async global::System.Threading.Tasks.Task remove_counterAsync(byte[] key, global::Apache.Cassandra.Test.ColumnPath path, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("remove_counter", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.remove_counterArgs() {
          Key = key,
          Path = path,
          Consistency_level = consistency_level,
        };
        
        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.remove_counterResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        return;
      }

      public async global::System.Threading.Tasks.Task batch_mutateAsync(Dictionary<byte[], Dictionary<string, List<global::Apache.Cassandra.Test.Mutation>>> mutation_map, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("batch_mutate", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.batch_mutateArgs() {
          Mutation_map = mutation_map,
          Consistency_level = consistency_level,
        };
        
        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.batch_mutateResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        return;
      }

      public async global::System.Threading.Tasks.Task truncateAsync(string cfname, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("truncate", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.truncateArgs() {
          Cfname = cfname,
        };
        
        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.truncateResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        return;
      }

      public async global::System.Threading.Tasks.Task<Dictionary<string, List<string>>> describe_schema_versionsAsync(CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("describe_schema_versions", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.describe_schema_versionsArgs() {
        };
        
        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.describe_schema_versionsResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_schema_versions failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<List<global::Apache.Cassandra.Test.KsDef>> describe_keyspacesAsync(CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("describe_keyspaces", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.describe_keyspacesArgs() {
        };
        
        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.describe_keyspacesResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_keyspaces failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<string> describe_cluster_nameAsync(CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("describe_cluster_name", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.describe_cluster_nameArgs() {
        };
        
        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.describe_cluster_nameResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_cluster_name failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<string> describe_versionAsync(CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("describe_version", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.describe_versionArgs() {
        };
        
        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.describe_versionResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_version failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<List<global::Apache.Cassandra.Test.TokenRange>> describe_ringAsync(string keyspace, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("describe_ring", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.describe_ringArgs() {
          Keyspace = keyspace,
        };
        
        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.describe_ringResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_ring failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<string> describe_partitionerAsync(CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("describe_partitioner", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.describe_partitionerArgs() {
        };
        
        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.describe_partitionerResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_partitioner failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<string> describe_snitchAsync(CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("describe_snitch", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.describe_snitchArgs() {
        };
        
        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.describe_snitchResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_snitch failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<global::Apache.Cassandra.Test.KsDef> describe_keyspaceAsync(string keyspace, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("describe_keyspace", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.describe_keyspaceArgs() {
          Keyspace = keyspace,
        };
        
        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.describe_keyspaceResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.nfe)
        {
          throw result.Nfe;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_keyspace failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<List<string>> describe_splitsAsync(string cfName, string start_token, string end_token, int keys_per_split, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("describe_splits", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.describe_splitsArgs() {
          CfName = cfName,
          Start_token = start_token,
          End_token = end_token,
          Keys_per_split = keys_per_split,
        };
        
        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.describe_splitsResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_splits failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<string> system_add_column_familyAsync(global::Apache.Cassandra.Test.CfDef cf_def, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("system_add_column_family", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.system_add_column_familyArgs() {
          Cf_def = cf_def,
        };
        
        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.system_add_column_familyResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.sde)
        {
          throw result.Sde;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_add_column_family failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<string> system_drop_column_familyAsync(string column_family, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("system_drop_column_family", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.system_drop_column_familyArgs() {
          Column_family = column_family,
        };
        
        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.system_drop_column_familyResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.sde)
        {
          throw result.Sde;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_drop_column_family failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<string> system_add_keyspaceAsync(global::Apache.Cassandra.Test.KsDef ks_def, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("system_add_keyspace", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.system_add_keyspaceArgs() {
          Ks_def = ks_def,
        };
        
        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.system_add_keyspaceResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.sde)
        {
          throw result.Sde;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_add_keyspace failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<string> system_drop_keyspaceAsync(string keyspace, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("system_drop_keyspace", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.system_drop_keyspaceArgs() {
          Keyspace = keyspace,
        };
        
        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.system_drop_keyspaceResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.sde)
        {
          throw result.Sde;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_drop_keyspace failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<string> system_update_keyspaceAsync(global::Apache.Cassandra.Test.KsDef ks_def, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("system_update_keyspace", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.system_update_keyspaceArgs() {
          Ks_def = ks_def,
        };
        
        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.system_update_keyspaceResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.sde)
        {
          throw result.Sde;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_update_keyspace failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<string> system_update_column_familyAsync(global::Apache.Cassandra.Test.CfDef cf_def, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("system_update_column_family", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.system_update_column_familyArgs() {
          Cf_def = cf_def,
        };
        
        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.system_update_column_familyResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.sde)
        {
          throw result.Sde;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_update_column_family failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<global::Apache.Cassandra.Test.CqlResult> execute_cql_queryAsync(byte[] query, global::Apache.Cassandra.Test.Compression compression, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("execute_cql_query", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.execute_cql_queryArgs() {
          Query = query,
          Compression = compression,
        };
        
        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.execute_cql_queryResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        if (result.__isset.sde)
        {
          throw result.Sde;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "execute_cql_query failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<global::Apache.Cassandra.Test.CqlPreparedResult> prepare_cql_queryAsync(byte[] query, global::Apache.Cassandra.Test.Compression compression, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("prepare_cql_query", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.prepare_cql_queryArgs() {
          Query = query,
          Compression = compression,
        };
        
        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.prepare_cql_queryResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "prepare_cql_query failed: unknown result");
      }

      public async global::System.Threading.Tasks.Task<global::Apache.Cassandra.Test.CqlResult> execute_prepared_cql_queryAsync(int itemId, List<string> values, CancellationToken cancellationToken = default)
      {
        await OutputProtocol.WriteMessageBeginAsync(new TMessage("execute_prepared_cql_query", TMessageType.Call, SeqId), cancellationToken);
        
        var args = new InternalStructs.execute_prepared_cql_queryArgs() {
          ItemId = itemId,
          Values = values,
        };
        
        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.execute_prepared_cql_queryResult();
        await result.ReadAsync(InputProtocol, cancellationToken);
        await InputProtocol.ReadMessageEndAsync(cancellationToken);
        if (result.__isset.success)
        {
          return result.Success;
        }
        if (result.__isset.ire)
        {
          throw result.Ire;
        }
        if (result.__isset.ue)
        {
          throw result.Ue;
        }
        if (result.__isset.te)
        {
          throw result.Te;
        }
        if (result.__isset.sde)
        {
          throw result.Sde;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "execute_prepared_cql_query 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_["login"] = login_ProcessAsync;
        processMap_["set_keyspace"] = set_keyspace_ProcessAsync;
        processMap_["get"] = get_ProcessAsync;
        processMap_["get_slice"] = get_slice_ProcessAsync;
        processMap_["get_count"] = get_count_ProcessAsync;
        processMap_["multiget_slice"] = multiget_slice_ProcessAsync;
        processMap_["multiget_count"] = multiget_count_ProcessAsync;
        processMap_["get_range_slices"] = get_range_slices_ProcessAsync;
        processMap_["get_indexed_slices"] = get_indexed_slices_ProcessAsync;
        processMap_["insert"] = insert_ProcessAsync;
        processMap_["add"] = add_ProcessAsync;
        processMap_["remove"] = remove_ProcessAsync;
        processMap_["remove_counter"] = remove_counter_ProcessAsync;
        processMap_["batch_mutate"] = batch_mutate_ProcessAsync;
        processMap_["truncate"] = truncate_ProcessAsync;
        processMap_["describe_schema_versions"] = describe_schema_versions_ProcessAsync;
        processMap_["describe_keyspaces"] = describe_keyspaces_ProcessAsync;
        processMap_["describe_cluster_name"] = describe_cluster_name_ProcessAsync;
        processMap_["describe_version"] = describe_version_ProcessAsync;
        processMap_["describe_ring"] = describe_ring_ProcessAsync;
        processMap_["describe_partitioner"] = describe_partitioner_ProcessAsync;
        processMap_["describe_snitch"] = describe_snitch_ProcessAsync;
        processMap_["describe_keyspace"] = describe_keyspace_ProcessAsync;
        processMap_["describe_splits"] = describe_splits_ProcessAsync;
        processMap_["system_add_column_family"] = system_add_column_family_ProcessAsync;
        processMap_["system_drop_column_family"] = system_drop_column_family_ProcessAsync;
        processMap_["system_add_keyspace"] = system_add_keyspace_ProcessAsync;
        processMap_["system_drop_keyspace"] = system_drop_keyspace_ProcessAsync;
        processMap_["system_update_keyspace"] = system_update_keyspace_ProcessAsync;
        processMap_["system_update_column_family"] = system_update_column_family_ProcessAsync;
        processMap_["execute_cql_query"] = execute_cql_query_ProcessAsync;
        processMap_["prepare_cql_query"] = prepare_cql_query_ProcessAsync;
        processMap_["execute_prepared_cql_query"] = execute_prepared_cql_query_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 login_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.loginArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.loginResult();
        try
        {
          try
          {
            await _iAsync.loginAsync(args.Auth_request, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.AuthenticationException authnx)
          {
            result.Authnx = authnx;
          }
          catch (global::Apache.Cassandra.Test.AuthorizationException authzx)
          {
            result.Authzx = authzx;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("login", 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("login", 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 set_keyspace_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.set_keyspaceArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.set_keyspaceResult();
        try
        {
          try
          {
            await _iAsync.set_keyspaceAsync(args.Keyspace, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("set_keyspace", 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("set_keyspace", 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 get_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.getArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.getResult();
        try
        {
          try
          {
            result.Success = await _iAsync.@getAsync(args.Key, args.Column_path, args.Consistency_level, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.NotFoundException nfe)
          {
            result.Nfe = nfe;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("get", 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("get", 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 get_slice_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.get_sliceArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.get_sliceResult();
        try
        {
          try
          {
            result.Success = await _iAsync.get_sliceAsync(args.Key, args.Column_parent, args.Predicate, args.Consistency_level, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("get_slice", 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("get_slice", 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 get_count_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.get_countArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.get_countResult();
        try
        {
          try
          {
            result.Success = await _iAsync.get_countAsync(args.Key, args.Column_parent, args.Predicate, args.Consistency_level, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("get_count", 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("get_count", 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 multiget_slice_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.multiget_sliceArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.multiget_sliceResult();
        try
        {
          try
          {
            result.Success = await _iAsync.multiget_sliceAsync(args.Keys, args.Column_parent, args.Predicate, args.Consistency_level, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("multiget_slice", 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("multiget_slice", 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 multiget_count_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.multiget_countArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.multiget_countResult();
        try
        {
          try
          {
            result.Success = await _iAsync.multiget_countAsync(args.Keys, args.Column_parent, args.Predicate, args.Consistency_level, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("multiget_count", 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("multiget_count", 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 get_range_slices_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.get_range_slicesArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.get_range_slicesResult();
        try
        {
          try
          {
            result.Success = await _iAsync.get_range_slicesAsync(args.Column_parent, args.Predicate, args.Range, args.Consistency_level, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("get_range_slices", 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("get_range_slices", 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 get_indexed_slices_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.get_indexed_slicesArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.get_indexed_slicesResult();
        try
        {
          try
          {
            result.Success = await _iAsync.get_indexed_slicesAsync(args.Column_parent, args.Index_clause, args.Column_predicate, args.Consistency_level, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("get_indexed_slices", 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("get_indexed_slices", 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 insert_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.insertArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.insertResult();
        try
        {
          try
          {
            await _iAsync.insertAsync(args.Key, args.Column_parent, args.Column, args.Consistency_level, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("insert", 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("insert", 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 add_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.addArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.addResult();
        try
        {
          try
          {
            await _iAsync.@addAsync(args.Key, args.Column_parent, args.Column, args.Consistency_level, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("add", 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("add", 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 remove_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.removeArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.removeResult();
        try
        {
          try
          {
            await _iAsync.@removeAsync(args.Key, args.Column_path, args.Timestamp, args.Consistency_level, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("remove", 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("remove", 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 remove_counter_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.remove_counterArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.remove_counterResult();
        try
        {
          try
          {
            await _iAsync.remove_counterAsync(args.Key, args.Path, args.Consistency_level, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("remove_counter", 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("remove_counter", 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 batch_mutate_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.batch_mutateArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.batch_mutateResult();
        try
        {
          try
          {
            await _iAsync.batch_mutateAsync(args.Mutation_map, args.Consistency_level, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("batch_mutate", 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("batch_mutate", 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 truncate_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.truncateArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.truncateResult();
        try
        {
          try
          {
            await _iAsync.truncateAsync(args.Cfname, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("truncate", 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("truncate", 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 describe_schema_versions_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.describe_schema_versionsArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.describe_schema_versionsResult();
        try
        {
          try
          {
            result.Success = await _iAsync.describe_schema_versionsAsync(cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("describe_schema_versions", 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("describe_schema_versions", 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 describe_keyspaces_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.describe_keyspacesArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.describe_keyspacesResult();
        try
        {
          try
          {
            result.Success = await _iAsync.describe_keyspacesAsync(cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("describe_keyspaces", 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("describe_keyspaces", 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 describe_cluster_name_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.describe_cluster_nameArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.describe_cluster_nameResult();
        try
        {
          result.Success = await _iAsync.describe_cluster_nameAsync(cancellationToken);
          await oprot.WriteMessageBeginAsync(new TMessage("describe_cluster_name", 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("describe_cluster_name", 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 describe_version_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.describe_versionArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.describe_versionResult();
        try
        {
          result.Success = await _iAsync.describe_versionAsync(cancellationToken);
          await oprot.WriteMessageBeginAsync(new TMessage("describe_version", 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("describe_version", 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 describe_ring_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.describe_ringArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.describe_ringResult();
        try
        {
          try
          {
            result.Success = await _iAsync.describe_ringAsync(args.Keyspace, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("describe_ring", 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("describe_ring", 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 describe_partitioner_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.describe_partitionerArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.describe_partitionerResult();
        try
        {
          result.Success = await _iAsync.describe_partitionerAsync(cancellationToken);
          await oprot.WriteMessageBeginAsync(new TMessage("describe_partitioner", 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("describe_partitioner", 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 describe_snitch_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.describe_snitchArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.describe_snitchResult();
        try
        {
          result.Success = await _iAsync.describe_snitchAsync(cancellationToken);
          await oprot.WriteMessageBeginAsync(new TMessage("describe_snitch", 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("describe_snitch", 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 describe_keyspace_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.describe_keyspaceArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.describe_keyspaceResult();
        try
        {
          try
          {
            result.Success = await _iAsync.describe_keyspaceAsync(args.Keyspace, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.NotFoundException nfe)
          {
            result.Nfe = nfe;
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("describe_keyspace", 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("describe_keyspace", 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 describe_splits_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.describe_splitsArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.describe_splitsResult();
        try
        {
          try
          {
            result.Success = await _iAsync.describe_splitsAsync(args.CfName, args.Start_token, args.End_token, args.Keys_per_split, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("describe_splits", 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("describe_splits", 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 system_add_column_family_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.system_add_column_familyArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.system_add_column_familyResult();
        try
        {
          try
          {
            result.Success = await _iAsync.system_add_column_familyAsync(args.Cf_def, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.SchemaDisagreementException sde)
          {
            result.Sde = sde;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("system_add_column_family", 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("system_add_column_family", 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 system_drop_column_family_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.system_drop_column_familyArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.system_drop_column_familyResult();
        try
        {
          try
          {
            result.Success = await _iAsync.system_drop_column_familyAsync(args.Column_family, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.SchemaDisagreementException sde)
          {
            result.Sde = sde;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("system_drop_column_family", 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("system_drop_column_family", 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 system_add_keyspace_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.system_add_keyspaceArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.system_add_keyspaceResult();
        try
        {
          try
          {
            result.Success = await _iAsync.system_add_keyspaceAsync(args.Ks_def, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.SchemaDisagreementException sde)
          {
            result.Sde = sde;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("system_add_keyspace", 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("system_add_keyspace", 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 system_drop_keyspace_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.system_drop_keyspaceArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.system_drop_keyspaceResult();
        try
        {
          try
          {
            result.Success = await _iAsync.system_drop_keyspaceAsync(args.Keyspace, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.SchemaDisagreementException sde)
          {
            result.Sde = sde;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("system_drop_keyspace", 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("system_drop_keyspace", 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 system_update_keyspace_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.system_update_keyspaceArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.system_update_keyspaceResult();
        try
        {
          try
          {
            result.Success = await _iAsync.system_update_keyspaceAsync(args.Ks_def, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.SchemaDisagreementException sde)
          {
            result.Sde = sde;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("system_update_keyspace", 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("system_update_keyspace", 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 system_update_column_family_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.system_update_column_familyArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.system_update_column_familyResult();
        try
        {
          try
          {
            result.Success = await _iAsync.system_update_column_familyAsync(args.Cf_def, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.SchemaDisagreementException sde)
          {
            result.Sde = sde;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("system_update_column_family", 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("system_update_column_family", 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 execute_cql_query_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.execute_cql_queryArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.execute_cql_queryResult();
        try
        {
          try
          {
            result.Success = await _iAsync.execute_cql_queryAsync(args.Query, args.Compression, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          catch (global::Apache.Cassandra.Test.SchemaDisagreementException sde)
          {
            result.Sde = sde;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("execute_cql_query", 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("execute_cql_query", 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 prepare_cql_query_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.prepare_cql_queryArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.prepare_cql_queryResult();
        try
        {
          try
          {
            result.Success = await _iAsync.prepare_cql_queryAsync(args.Query, args.Compression, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("prepare_cql_query", 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("prepare_cql_query", 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 execute_prepared_cql_query_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
      {
        var args = new InternalStructs.execute_prepared_cql_queryArgs();
        await args.ReadAsync(iprot, cancellationToken);
        await iprot.ReadMessageEndAsync(cancellationToken);
        var result = new InternalStructs.execute_prepared_cql_queryResult();
        try
        {
          try
          {
            result.Success = await _iAsync.execute_prepared_cql_queryAsync(args.ItemId, args.Values, cancellationToken);
          }
          catch (global::Apache.Cassandra.Test.InvalidRequestException ire)
          {
            result.Ire = ire;
          }
          catch (global::Apache.Cassandra.Test.UnavailableException ue)
          {
            result.Ue = ue;
          }
          catch (global::Apache.Cassandra.Test.TimedOutException te)
          {
            result.Te = te;
          }
          catch (global::Apache.Cassandra.Test.SchemaDisagreementException sde)
          {
            result.Sde = sde;
          }
          await oprot.WriteMessageBeginAsync(new TMessage("execute_prepared_cql_query", 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("execute_prepared_cql_query", TMessageType.Exception, seqid), cancellationToken);
          await x.WriteAsync(oprot, cancellationToken);
        }
        await oprot.WriteMessageEndAsync(cancellationToken);
        await oprot.Transport.FlushAsync(cancellationToken);
      }

    }

    public class InternalStructs
    {

      [DataContract(Namespace="")]
      public partial class loginArgs : TBase
      {

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.AuthenticationRequest Auth_request { get; set; }

        public loginArgs()
        {
        }

        public loginArgs(global::Apache.Cassandra.Test.AuthenticationRequest auth_request) : this()
        {
          this.Auth_request = auth_request;
        }

        public loginArgs DeepCopy()
        {
          var tmp149 = new loginArgs();
          if((Auth_request != null))
          {
            tmp149.Auth_request = (global::Apache.Cassandra.Test.AuthenticationRequest)this.Auth_request.DeepCopy();
          }
          return tmp149;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          try
          {
            bool isset_auth_request = false;
            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)
                  {
                    Auth_request = new global::Apache.Cassandra.Test.AuthenticationRequest();
                    await Auth_request.ReadAsync(iprot, cancellationToken);
                    isset_auth_request = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_auth_request)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

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

        public override bool Equals(object that)
        {
          if (!(that is loginArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Auth_request, other.Auth_request);
        }

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

        public override string ToString()
        {
          var sb = new StringBuilder("login_args(");
          if((Auth_request != null))
          {
            sb.Append(", Auth_request: ");
            Auth_request.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class loginResult : TBase
      {
        private global::Apache.Cassandra.Test.AuthenticationException _authnx;
        private global::Apache.Cassandra.Test.AuthorizationException _authzx;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.AuthenticationException Authnx
        {
          get
          {
            return _authnx;
          }
          set
          {
            __isset.authnx = true;
            this._authnx = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.AuthorizationException Authzx
        {
          get
          {
            return _authzx;
          }
          set
          {
            __isset.authzx = true;
            this._authzx = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool authnx;
          [DataMember]
          public bool authzx;
        }

        #region XmlSerializer support

        public bool ShouldSerializeAuthnx()
        {
          return __isset.authnx;
        }

        public bool ShouldSerializeAuthzx()
        {
          return __isset.authzx;
        }

        #endregion XmlSerializer support

        public loginResult()
        {
        }

        public loginResult DeepCopy()
        {
          var tmp151 = new loginResult();
          if((Authnx != null) && __isset.authnx)
          {
            tmp151.Authnx = (global::Apache.Cassandra.Test.AuthenticationException)this.Authnx.DeepCopy();
          }
          tmp151.__isset.authnx = this.__isset.authnx;
          if((Authzx != null) && __isset.authzx)
          {
            tmp151.Authzx = (global::Apache.Cassandra.Test.AuthorizationException)this.Authzx.DeepCopy();
          }
          tmp151.__isset.authzx = this.__isset.authzx;
          return tmp151;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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)
                  {
                    Authnx = new global::Apache.Cassandra.Test.AuthenticationException();
                    await Authnx.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Authzx = new global::Apache.Cassandra.Test.AuthorizationException();
                    await Authzx.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.authnx)
            {
              if (Authnx != null)
              {
                field.Name = "Authnx";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Authnx.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.authzx)
            {
              if (Authzx != null)
              {
                field.Name = "Authzx";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Authzx.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is loginResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.authnx == other.__isset.authnx) && ((!__isset.authnx) || (System.Object.Equals(Authnx, other.Authnx))))
            && ((__isset.authzx == other.__isset.authzx) && ((!__isset.authzx) || (System.Object.Equals(Authzx, other.Authzx))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Authnx != null) && __isset.authnx)
            {
              hashcode = (hashcode * 397) + Authnx.GetHashCode();
            }
            if((Authzx != null) && __isset.authzx)
            {
              hashcode = (hashcode * 397) + Authzx.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("login_result(");
          int tmp152 = 0;
          if((Authnx != null) && __isset.authnx)
          {
            if(0 < tmp152++) { sb.Append(", "); }
            sb.Append("Authnx: ");
            Authnx.ToString(sb);
          }
          if((Authzx != null) && __isset.authzx)
          {
            if(0 < tmp152++) { sb.Append(", "); }
            sb.Append("Authzx: ");
            Authzx.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class set_keyspaceArgs : TBase
      {

        [DataMember(Order = 0)]
        public string Keyspace { get; set; }

        public set_keyspaceArgs()
        {
        }

        public set_keyspaceArgs(string keyspace) : this()
        {
          this.Keyspace = keyspace;
        }

        public set_keyspaceArgs DeepCopy()
        {
          var tmp153 = new set_keyspaceArgs();
          if((Keyspace != null))
          {
            tmp153.Keyspace = this.Keyspace;
          }
          return tmp153;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Keyspace = await iprot.ReadStringAsync(cancellationToken);
                    isset_keyspace = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_keyspace)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

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

        public override bool Equals(object that)
        {
          if (!(that is set_keyspaceArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Keyspace, other.Keyspace);
        }

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

        public override string ToString()
        {
          var sb = new StringBuilder("set_keyspace_args(");
          if((Keyspace != null))
          {
            sb.Append(", Keyspace: ");
            Keyspace.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class set_keyspaceResult : TBase
      {
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool ire;
        }

        #region XmlSerializer support

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        #endregion XmlSerializer support

        public set_keyspaceResult()
        {
        }

        public set_keyspaceResult DeepCopy()
        {
          var tmp155 = new set_keyspaceResult();
          if((Ire != null) && __isset.ire)
          {
            tmp155.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp155.__isset.ire = this.__isset.ire;
          return tmp155;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

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

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

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

        public override string ToString()
        {
          var sb = new StringBuilder("set_keyspace_result(");
          int tmp156 = 0;
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp156++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class getArgs : TBase
      {

        [DataMember(Order = 0)]
        public byte[] Key { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ColumnPath Column_path { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.ConsistencyLevel"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ConsistencyLevel Consistency_level { get; set; }

        public getArgs()
        {
          this.Consistency_level = global::Apache.Cassandra.Test.ConsistencyLevel.ONE;
        }

        public getArgs(byte[] key, global::Apache.Cassandra.Test.ColumnPath column_path, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level) : this()
        {
          this.Key = key;
          this.Column_path = column_path;
          this.Consistency_level = consistency_level;
        }

        public getArgs DeepCopy()
        {
          var tmp157 = new getArgs();
          if((Key != null))
          {
            tmp157.Key = this.Key.ToArray();
          }
          if((Column_path != null))
          {
            tmp157.Column_path = (global::Apache.Cassandra.Test.ColumnPath)this.Column_path.DeepCopy();
          }
          tmp157.Consistency_level = this.Consistency_level;
          return tmp157;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Key = await iprot.ReadBinaryAsync(cancellationToken);
                    isset_key = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Column_path = new global::Apache.Cassandra.Test.ColumnPath();
                    await Column_path.ReadAsync(iprot, cancellationToken);
                    isset_column_path = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.I32)
                  {
                    Consistency_level = (global::Apache.Cassandra.Test.ConsistencyLevel)await iprot.ReadI32Async(cancellationToken);
                    isset_consistency_level = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_key)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_column_path)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_consistency_level)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("get_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Key != null))
            {
              field.Name = "key";
              field.Type = TType.String;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteBinaryAsync(Key, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Column_path != null))
            {
              field.Name = "column_path";
              field.Type = TType.Struct;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column_path.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "consistency_level";
            field.Type = TType.I32;
            field.ID = 3;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Consistency_level, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is getArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return TCollections.Equals(Key, other.Key)
            && System.Object.Equals(Column_path, other.Column_path)
            && System.Object.Equals(Consistency_level, other.Consistency_level);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Key != null))
            {
              hashcode = (hashcode * 397) + Key.GetHashCode();
            }
            if((Column_path != null))
            {
              hashcode = (hashcode * 397) + Column_path.GetHashCode();
            }
            hashcode = (hashcode * 397) + Consistency_level.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("get_args(");
          if((Key != null))
          {
            sb.Append(", Key: ");
            Key.ToString(sb);
          }
          if((Column_path != null))
          {
            sb.Append(", Column_path: ");
            Column_path.ToString(sb);
          }
          sb.Append(", Consistency_level: ");
          Consistency_level.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class getResult : TBase
      {
        private global::Apache.Cassandra.Test.ColumnOrSuperColumn _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.NotFoundException _nfe;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ColumnOrSuperColumn Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.NotFoundException Nfe
        {
          get
          {
            return _nfe;
          }
          set
          {
            __isset.nfe = true;
            this._nfe = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool nfe;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeNfe()
        {
          return __isset.nfe;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public getResult()
        {
        }

        public getResult DeepCopy()
        {
          var tmp159 = new getResult();
          if((Success != null) && __isset.success)
          {
            tmp159.Success = (global::Apache.Cassandra.Test.ColumnOrSuperColumn)this.Success.DeepCopy();
          }
          tmp159.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp159.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp159.__isset.ire = this.__isset.ire;
          if((Nfe != null) && __isset.nfe)
          {
            tmp159.Nfe = (global::Apache.Cassandra.Test.NotFoundException)this.Nfe.DeepCopy();
          }
          tmp159.__isset.nfe = this.__isset.nfe;
          if((Ue != null) && __isset.ue)
          {
            tmp159.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp159.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp159.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp159.__isset.te = this.__isset.te;
          return tmp159;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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 global::Apache.Cassandra.Test.ColumnOrSuperColumn();
                    await Success.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Nfe = new global::Apache.Cassandra.Test.NotFoundException();
                    await Nfe.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("get_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);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.nfe)
            {
              if (Nfe != null)
              {
                field.Name = "Nfe";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Nfe.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 4;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is getResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))))
            && ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.nfe == other.__isset.nfe) && ((!__isset.nfe) || (System.Object.Equals(Nfe, other.Nfe))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Success != null) && __isset.success)
            {
              hashcode = (hashcode * 397) + Success.GetHashCode();
            }
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Nfe != null) && __isset.nfe)
            {
              hashcode = (hashcode * 397) + Nfe.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("get_result(");
          int tmp160 = 0;
          if((Success != null) && __isset.success)
          {
            if(0 < tmp160++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp160++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Nfe != null) && __isset.nfe)
          {
            if(0 < tmp160++) { sb.Append(", "); }
            sb.Append("Nfe: ");
            Nfe.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp160++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp160++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class get_sliceArgs : TBase
      {

        [DataMember(Order = 0)]
        public byte[] Key { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ColumnParent Column_parent { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SlicePredicate Predicate { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.ConsistencyLevel"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ConsistencyLevel Consistency_level { get; set; }

        public get_sliceArgs()
        {
          this.Consistency_level = global::Apache.Cassandra.Test.ConsistencyLevel.ONE;
        }

        public get_sliceArgs(byte[] key, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level) : this()
        {
          this.Key = key;
          this.Column_parent = column_parent;
          this.Predicate = predicate;
          this.Consistency_level = consistency_level;
        }

        public get_sliceArgs DeepCopy()
        {
          var tmp161 = new get_sliceArgs();
          if((Key != null))
          {
            tmp161.Key = this.Key.ToArray();
          }
          if((Column_parent != null))
          {
            tmp161.Column_parent = (global::Apache.Cassandra.Test.ColumnParent)this.Column_parent.DeepCopy();
          }
          if((Predicate != null))
          {
            tmp161.Predicate = (global::Apache.Cassandra.Test.SlicePredicate)this.Predicate.DeepCopy();
          }
          tmp161.Consistency_level = this.Consistency_level;
          return tmp161;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Key = await iprot.ReadBinaryAsync(cancellationToken);
                    isset_key = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Column_parent = new global::Apache.Cassandra.Test.ColumnParent();
                    await Column_parent.ReadAsync(iprot, cancellationToken);
                    isset_column_parent = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Predicate = new global::Apache.Cassandra.Test.SlicePredicate();
                    await Predicate.ReadAsync(iprot, cancellationToken);
                    isset_predicate = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.I32)
                  {
                    Consistency_level = (global::Apache.Cassandra.Test.ConsistencyLevel)await iprot.ReadI32Async(cancellationToken);
                    isset_consistency_level = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_key)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_column_parent)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_predicate)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_consistency_level)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("get_slice_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Key != null))
            {
              field.Name = "key";
              field.Type = TType.String;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteBinaryAsync(Key, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Column_parent != null))
            {
              field.Name = "column_parent";
              field.Type = TType.Struct;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column_parent.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Predicate != null))
            {
              field.Name = "predicate";
              field.Type = TType.Struct;
              field.ID = 3;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Predicate.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "consistency_level";
            field.Type = TType.I32;
            field.ID = 4;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Consistency_level, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is get_sliceArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return TCollections.Equals(Key, other.Key)
            && System.Object.Equals(Column_parent, other.Column_parent)
            && System.Object.Equals(Predicate, other.Predicate)
            && System.Object.Equals(Consistency_level, other.Consistency_level);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Key != null))
            {
              hashcode = (hashcode * 397) + Key.GetHashCode();
            }
            if((Column_parent != null))
            {
              hashcode = (hashcode * 397) + Column_parent.GetHashCode();
            }
            if((Predicate != null))
            {
              hashcode = (hashcode * 397) + Predicate.GetHashCode();
            }
            hashcode = (hashcode * 397) + Consistency_level.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("get_slice_args(");
          if((Key != null))
          {
            sb.Append(", Key: ");
            Key.ToString(sb);
          }
          if((Column_parent != null))
          {
            sb.Append(", Column_parent: ");
            Column_parent.ToString(sb);
          }
          if((Predicate != null))
          {
            sb.Append(", Predicate: ");
            Predicate.ToString(sb);
          }
          sb.Append(", Consistency_level: ");
          Consistency_level.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class get_sliceResult : TBase
      {
        private List<global::Apache.Cassandra.Test.ColumnOrSuperColumn> _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public List<global::Apache.Cassandra.Test.ColumnOrSuperColumn> Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public get_sliceResult()
        {
        }

        public get_sliceResult DeepCopy()
        {
          var tmp163 = new get_sliceResult();
          if((Success != null) && __isset.success)
          {
            tmp163.Success = this.Success.DeepCopy();
          }
          tmp163.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp163.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp163.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp163.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp163.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp163.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp163.__isset.te = this.__isset.te;
          return tmp163;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.List)
                  {
                    {
                      TList _list164 = await iprot.ReadListBeginAsync(cancellationToken);
                      Success = new List<global::Apache.Cassandra.Test.ColumnOrSuperColumn>(_list164.Count);
                      for(int _i165 = 0; _i165 < _list164.Count; ++_i165)
                      {
                        global::Apache.Cassandra.Test.ColumnOrSuperColumn _elem166;
                        _elem166 = new global::Apache.Cassandra.Test.ColumnOrSuperColumn();
                        await _elem166.ReadAsync(iprot, cancellationToken);
                        Success.Add(_elem166);
                      }
                      await iprot.ReadListEndAsync(cancellationToken);
                    }
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.List;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                {
                  await oprot.WriteListBeginAsync(new TList(TType.Struct, Success.Count), cancellationToken);
                  foreach (global::Apache.Cassandra.Test.ColumnOrSuperColumn _iter167 in Success)
                  {
                    await _iter167.WriteAsync(oprot, cancellationToken);
                  }
                  await oprot.WriteListEndAsync(cancellationToken);
                }
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is get_sliceResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.success == other.__isset.success) && ((!__isset.success) || (TCollections.Equals(Success, other.Success))))
            && ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Success != null) && __isset.success)
            {
              hashcode = (hashcode * 397) + TCollections.GetHashCode(Success);
            }
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("get_slice_result(");
          int tmp168 = 0;
          if((Success != null) && __isset.success)
          {
            if(0 < tmp168++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp168++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp168++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp168++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class get_countArgs : TBase
      {

        [DataMember(Order = 0)]
        public byte[] Key { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ColumnParent Column_parent { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SlicePredicate Predicate { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.ConsistencyLevel"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ConsistencyLevel Consistency_level { get; set; }

        public get_countArgs()
        {
          this.Consistency_level = global::Apache.Cassandra.Test.ConsistencyLevel.ONE;
        }

        public get_countArgs(byte[] key, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level) : this()
        {
          this.Key = key;
          this.Column_parent = column_parent;
          this.Predicate = predicate;
          this.Consistency_level = consistency_level;
        }

        public get_countArgs DeepCopy()
        {
          var tmp169 = new get_countArgs();
          if((Key != null))
          {
            tmp169.Key = this.Key.ToArray();
          }
          if((Column_parent != null))
          {
            tmp169.Column_parent = (global::Apache.Cassandra.Test.ColumnParent)this.Column_parent.DeepCopy();
          }
          if((Predicate != null))
          {
            tmp169.Predicate = (global::Apache.Cassandra.Test.SlicePredicate)this.Predicate.DeepCopy();
          }
          tmp169.Consistency_level = this.Consistency_level;
          return tmp169;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Key = await iprot.ReadBinaryAsync(cancellationToken);
                    isset_key = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Column_parent = new global::Apache.Cassandra.Test.ColumnParent();
                    await Column_parent.ReadAsync(iprot, cancellationToken);
                    isset_column_parent = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Predicate = new global::Apache.Cassandra.Test.SlicePredicate();
                    await Predicate.ReadAsync(iprot, cancellationToken);
                    isset_predicate = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.I32)
                  {
                    Consistency_level = (global::Apache.Cassandra.Test.ConsistencyLevel)await iprot.ReadI32Async(cancellationToken);
                    isset_consistency_level = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_key)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_column_parent)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_predicate)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_consistency_level)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("get_count_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Key != null))
            {
              field.Name = "key";
              field.Type = TType.String;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteBinaryAsync(Key, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Column_parent != null))
            {
              field.Name = "column_parent";
              field.Type = TType.Struct;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column_parent.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Predicate != null))
            {
              field.Name = "predicate";
              field.Type = TType.Struct;
              field.ID = 3;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Predicate.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "consistency_level";
            field.Type = TType.I32;
            field.ID = 4;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Consistency_level, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is get_countArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return TCollections.Equals(Key, other.Key)
            && System.Object.Equals(Column_parent, other.Column_parent)
            && System.Object.Equals(Predicate, other.Predicate)
            && System.Object.Equals(Consistency_level, other.Consistency_level);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Key != null))
            {
              hashcode = (hashcode * 397) + Key.GetHashCode();
            }
            if((Column_parent != null))
            {
              hashcode = (hashcode * 397) + Column_parent.GetHashCode();
            }
            if((Predicate != null))
            {
              hashcode = (hashcode * 397) + Predicate.GetHashCode();
            }
            hashcode = (hashcode * 397) + Consistency_level.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("get_count_args(");
          if((Key != null))
          {
            sb.Append(", Key: ");
            Key.ToString(sb);
          }
          if((Column_parent != null))
          {
            sb.Append(", Column_parent: ");
            Column_parent.ToString(sb);
          }
          if((Predicate != null))
          {
            sb.Append(", Predicate: ");
            Predicate.ToString(sb);
          }
          sb.Append(", Consistency_level: ");
          Consistency_level.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class get_countResult : TBase
      {
        private int _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public int Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public get_countResult()
        {
        }

        public get_countResult DeepCopy()
        {
          var tmp171 = new get_countResult();
          if(__isset.success)
          {
            tmp171.Success = this.Success;
          }
          tmp171.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp171.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp171.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp171.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp171.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp171.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp171.__isset.te = this.__isset.te;
          return tmp171;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.I32)
                  {
                    Success = await iprot.ReadI32Async(cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              field.Name = "Success";
              field.Type = TType.I32;
              field.ID = 0;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteI32Async(Success, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is get_countResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))))
            && ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

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

        public override string ToString()
        {
          var sb = new StringBuilder("get_count_result(");
          int tmp172 = 0;
          if(__isset.success)
          {
            if(0 < tmp172++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp172++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp172++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp172++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class multiget_sliceArgs : TBase
      {

        [DataMember(Order = 0)]
        public List<byte[]> Keys { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ColumnParent Column_parent { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SlicePredicate Predicate { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.ConsistencyLevel"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ConsistencyLevel Consistency_level { get; set; }

        public multiget_sliceArgs()
        {
          this.Consistency_level = global::Apache.Cassandra.Test.ConsistencyLevel.ONE;
        }

        public multiget_sliceArgs(List<byte[]> keys, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level) : this()
        {
          this.Keys = keys;
          this.Column_parent = column_parent;
          this.Predicate = predicate;
          this.Consistency_level = consistency_level;
        }

        public multiget_sliceArgs DeepCopy()
        {
          var tmp173 = new multiget_sliceArgs();
          if((Keys != null))
          {
            tmp173.Keys = this.Keys.DeepCopy();
          }
          if((Column_parent != null))
          {
            tmp173.Column_parent = (global::Apache.Cassandra.Test.ColumnParent)this.Column_parent.DeepCopy();
          }
          if((Predicate != null))
          {
            tmp173.Predicate = (global::Apache.Cassandra.Test.SlicePredicate)this.Predicate.DeepCopy();
          }
          tmp173.Consistency_level = this.Consistency_level;
          return tmp173;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          try
          {
            bool isset_keys = false;
            bool isset_column_parent = false;
            bool isset_predicate = false;
            bool isset_consistency_level = false;
            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.List)
                  {
                    {
                      TList _list174 = await iprot.ReadListBeginAsync(cancellationToken);
                      Keys = new List<byte[]>(_list174.Count);
                      for(int _i175 = 0; _i175 < _list174.Count; ++_i175)
                      {
                        byte[] _elem176;
                        _elem176 = await iprot.ReadBinaryAsync(cancellationToken);
                        Keys.Add(_elem176);
                      }
                      await iprot.ReadListEndAsync(cancellationToken);
                    }
                    isset_keys = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Column_parent = new global::Apache.Cassandra.Test.ColumnParent();
                    await Column_parent.ReadAsync(iprot, cancellationToken);
                    isset_column_parent = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Predicate = new global::Apache.Cassandra.Test.SlicePredicate();
                    await Predicate.ReadAsync(iprot, cancellationToken);
                    isset_predicate = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.I32)
                  {
                    Consistency_level = (global::Apache.Cassandra.Test.ConsistencyLevel)await iprot.ReadI32Async(cancellationToken);
                    isset_consistency_level = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_keys)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_column_parent)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_predicate)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_consistency_level)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("multiget_slice_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Keys != null))
            {
              field.Name = "keys";
              field.Type = TType.List;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              {
                await oprot.WriteListBeginAsync(new TList(TType.String, Keys.Count), cancellationToken);
                foreach (byte[] _iter177 in Keys)
                {
                  await oprot.WriteBinaryAsync(_iter177, cancellationToken);
                }
                await oprot.WriteListEndAsync(cancellationToken);
              }
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Column_parent != null))
            {
              field.Name = "column_parent";
              field.Type = TType.Struct;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column_parent.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Predicate != null))
            {
              field.Name = "predicate";
              field.Type = TType.Struct;
              field.ID = 3;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Predicate.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "consistency_level";
            field.Type = TType.I32;
            field.ID = 4;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Consistency_level, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is multiget_sliceArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return TCollections.Equals(Keys, other.Keys)
            && System.Object.Equals(Column_parent, other.Column_parent)
            && System.Object.Equals(Predicate, other.Predicate)
            && System.Object.Equals(Consistency_level, other.Consistency_level);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Keys != null))
            {
              hashcode = (hashcode * 397) + TCollections.GetHashCode(Keys);
            }
            if((Column_parent != null))
            {
              hashcode = (hashcode * 397) + Column_parent.GetHashCode();
            }
            if((Predicate != null))
            {
              hashcode = (hashcode * 397) + Predicate.GetHashCode();
            }
            hashcode = (hashcode * 397) + Consistency_level.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("multiget_slice_args(");
          if((Keys != null))
          {
            sb.Append(", Keys: ");
            Keys.ToString(sb);
          }
          if((Column_parent != null))
          {
            sb.Append(", Column_parent: ");
            Column_parent.ToString(sb);
          }
          if((Predicate != null))
          {
            sb.Append(", Predicate: ");
            Predicate.ToString(sb);
          }
          sb.Append(", Consistency_level: ");
          Consistency_level.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class multiget_sliceResult : TBase
      {
        private Dictionary<byte[], List<global::Apache.Cassandra.Test.ColumnOrSuperColumn>> _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public Dictionary<byte[], List<global::Apache.Cassandra.Test.ColumnOrSuperColumn>> Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public multiget_sliceResult()
        {
        }

        public multiget_sliceResult DeepCopy()
        {
          var tmp179 = new multiget_sliceResult();
          if((Success != null) && __isset.success)
          {
            tmp179.Success = this.Success.DeepCopy();
          }
          tmp179.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp179.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp179.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp179.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp179.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp179.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp179.__isset.te = this.__isset.te;
          return tmp179;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.Map)
                  {
                    {
                      TMap _map180 = await iprot.ReadMapBeginAsync(cancellationToken);
                      Success = new Dictionary<byte[], List<global::Apache.Cassandra.Test.ColumnOrSuperColumn>>(_map180.Count);
                      for(int _i181 = 0; _i181 < _map180.Count; ++_i181)
                      {
                        byte[] _key182;
                        List<global::Apache.Cassandra.Test.ColumnOrSuperColumn> _val183;
                        _key182 = await iprot.ReadBinaryAsync(cancellationToken);
                        {
                          TList _list184 = await iprot.ReadListBeginAsync(cancellationToken);
                          _val183 = new List<global::Apache.Cassandra.Test.ColumnOrSuperColumn>(_list184.Count);
                          for(int _i185 = 0; _i185 < _list184.Count; ++_i185)
                          {
                            global::Apache.Cassandra.Test.ColumnOrSuperColumn _elem186;
                            _elem186 = new global::Apache.Cassandra.Test.ColumnOrSuperColumn();
                            await _elem186.ReadAsync(iprot, cancellationToken);
                            _val183.Add(_elem186);
                          }
                          await iprot.ReadListEndAsync(cancellationToken);
                        }
                        Success[_key182] = _val183;
                      }
                      await iprot.ReadMapEndAsync(cancellationToken);
                    }
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.Map;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                {
                  await oprot.WriteMapBeginAsync(new TMap(TType.String, TType.List, Success.Count), cancellationToken);
                  foreach (byte[] _iter187 in Success.Keys)
                  {
                    await oprot.WriteBinaryAsync(_iter187, cancellationToken);
                    {
                      await oprot.WriteListBeginAsync(new TList(TType.Struct, Success[_iter187].Count), cancellationToken);
                      foreach (global::Apache.Cassandra.Test.ColumnOrSuperColumn _iter188 in Success[_iter187])
                      {
                        await _iter188.WriteAsync(oprot, cancellationToken);
                      }
                      await oprot.WriteListEndAsync(cancellationToken);
                    }
                  }
                  await oprot.WriteMapEndAsync(cancellationToken);
                }
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is multiget_sliceResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.success == other.__isset.success) && ((!__isset.success) || (TCollections.Equals(Success, other.Success))))
            && ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Success != null) && __isset.success)
            {
              hashcode = (hashcode * 397) + TCollections.GetHashCode(Success);
            }
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("multiget_slice_result(");
          int tmp189 = 0;
          if((Success != null) && __isset.success)
          {
            if(0 < tmp189++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp189++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp189++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp189++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class multiget_countArgs : TBase
      {

        [DataMember(Order = 0)]
        public List<byte[]> Keys { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ColumnParent Column_parent { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SlicePredicate Predicate { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.ConsistencyLevel"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ConsistencyLevel Consistency_level { get; set; }

        public multiget_countArgs()
        {
          this.Consistency_level = global::Apache.Cassandra.Test.ConsistencyLevel.ONE;
        }

        public multiget_countArgs(List<byte[]> keys, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level) : this()
        {
          this.Keys = keys;
          this.Column_parent = column_parent;
          this.Predicate = predicate;
          this.Consistency_level = consistency_level;
        }

        public multiget_countArgs DeepCopy()
        {
          var tmp190 = new multiget_countArgs();
          if((Keys != null))
          {
            tmp190.Keys = this.Keys.DeepCopy();
          }
          if((Column_parent != null))
          {
            tmp190.Column_parent = (global::Apache.Cassandra.Test.ColumnParent)this.Column_parent.DeepCopy();
          }
          if((Predicate != null))
          {
            tmp190.Predicate = (global::Apache.Cassandra.Test.SlicePredicate)this.Predicate.DeepCopy();
          }
          tmp190.Consistency_level = this.Consistency_level;
          return tmp190;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          try
          {
            bool isset_keys = false;
            bool isset_column_parent = false;
            bool isset_predicate = false;
            bool isset_consistency_level = false;
            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.List)
                  {
                    {
                      TList _list191 = await iprot.ReadListBeginAsync(cancellationToken);
                      Keys = new List<byte[]>(_list191.Count);
                      for(int _i192 = 0; _i192 < _list191.Count; ++_i192)
                      {
                        byte[] _elem193;
                        _elem193 = await iprot.ReadBinaryAsync(cancellationToken);
                        Keys.Add(_elem193);
                      }
                      await iprot.ReadListEndAsync(cancellationToken);
                    }
                    isset_keys = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Column_parent = new global::Apache.Cassandra.Test.ColumnParent();
                    await Column_parent.ReadAsync(iprot, cancellationToken);
                    isset_column_parent = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Predicate = new global::Apache.Cassandra.Test.SlicePredicate();
                    await Predicate.ReadAsync(iprot, cancellationToken);
                    isset_predicate = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.I32)
                  {
                    Consistency_level = (global::Apache.Cassandra.Test.ConsistencyLevel)await iprot.ReadI32Async(cancellationToken);
                    isset_consistency_level = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_keys)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_column_parent)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_predicate)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_consistency_level)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("multiget_count_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Keys != null))
            {
              field.Name = "keys";
              field.Type = TType.List;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              {
                await oprot.WriteListBeginAsync(new TList(TType.String, Keys.Count), cancellationToken);
                foreach (byte[] _iter194 in Keys)
                {
                  await oprot.WriteBinaryAsync(_iter194, cancellationToken);
                }
                await oprot.WriteListEndAsync(cancellationToken);
              }
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Column_parent != null))
            {
              field.Name = "column_parent";
              field.Type = TType.Struct;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column_parent.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Predicate != null))
            {
              field.Name = "predicate";
              field.Type = TType.Struct;
              field.ID = 3;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Predicate.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "consistency_level";
            field.Type = TType.I32;
            field.ID = 4;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Consistency_level, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is multiget_countArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return TCollections.Equals(Keys, other.Keys)
            && System.Object.Equals(Column_parent, other.Column_parent)
            && System.Object.Equals(Predicate, other.Predicate)
            && System.Object.Equals(Consistency_level, other.Consistency_level);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Keys != null))
            {
              hashcode = (hashcode * 397) + TCollections.GetHashCode(Keys);
            }
            if((Column_parent != null))
            {
              hashcode = (hashcode * 397) + Column_parent.GetHashCode();
            }
            if((Predicate != null))
            {
              hashcode = (hashcode * 397) + Predicate.GetHashCode();
            }
            hashcode = (hashcode * 397) + Consistency_level.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("multiget_count_args(");
          if((Keys != null))
          {
            sb.Append(", Keys: ");
            Keys.ToString(sb);
          }
          if((Column_parent != null))
          {
            sb.Append(", Column_parent: ");
            Column_parent.ToString(sb);
          }
          if((Predicate != null))
          {
            sb.Append(", Predicate: ");
            Predicate.ToString(sb);
          }
          sb.Append(", Consistency_level: ");
          Consistency_level.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class multiget_countResult : TBase
      {
        private Dictionary<byte[], int> _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public Dictionary<byte[], int> Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public multiget_countResult()
        {
        }

        public multiget_countResult DeepCopy()
        {
          var tmp196 = new multiget_countResult();
          if((Success != null) && __isset.success)
          {
            tmp196.Success = this.Success.DeepCopy();
          }
          tmp196.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp196.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp196.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp196.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp196.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp196.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp196.__isset.te = this.__isset.te;
          return tmp196;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.Map)
                  {
                    {
                      TMap _map197 = await iprot.ReadMapBeginAsync(cancellationToken);
                      Success = new Dictionary<byte[], int>(_map197.Count);
                      for(int _i198 = 0; _i198 < _map197.Count; ++_i198)
                      {
                        byte[] _key199;
                        int _val200;
                        _key199 = await iprot.ReadBinaryAsync(cancellationToken);
                        _val200 = await iprot.ReadI32Async(cancellationToken);
                        Success[_key199] = _val200;
                      }
                      await iprot.ReadMapEndAsync(cancellationToken);
                    }
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.Map;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                {
                  await oprot.WriteMapBeginAsync(new TMap(TType.String, TType.I32, Success.Count), cancellationToken);
                  foreach (byte[] _iter201 in Success.Keys)
                  {
                    await oprot.WriteBinaryAsync(_iter201, cancellationToken);
                    await oprot.WriteI32Async(Success[_iter201], cancellationToken);
                  }
                  await oprot.WriteMapEndAsync(cancellationToken);
                }
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is multiget_countResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.success == other.__isset.success) && ((!__isset.success) || (TCollections.Equals(Success, other.Success))))
            && ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Success != null) && __isset.success)
            {
              hashcode = (hashcode * 397) + TCollections.GetHashCode(Success);
            }
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("multiget_count_result(");
          int tmp202 = 0;
          if((Success != null) && __isset.success)
          {
            if(0 < tmp202++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp202++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp202++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp202++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class get_range_slicesArgs : TBase
      {

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ColumnParent Column_parent { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SlicePredicate Predicate { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.KeyRange Range { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.ConsistencyLevel"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ConsistencyLevel Consistency_level { get; set; }

        public get_range_slicesArgs()
        {
          this.Consistency_level = global::Apache.Cassandra.Test.ConsistencyLevel.ONE;
        }

        public get_range_slicesArgs(global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.SlicePredicate predicate, global::Apache.Cassandra.Test.KeyRange range, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level) : this()
        {
          this.Column_parent = column_parent;
          this.Predicate = predicate;
          this.Range = range;
          this.Consistency_level = consistency_level;
        }

        public get_range_slicesArgs DeepCopy()
        {
          var tmp203 = new get_range_slicesArgs();
          if((Column_parent != null))
          {
            tmp203.Column_parent = (global::Apache.Cassandra.Test.ColumnParent)this.Column_parent.DeepCopy();
          }
          if((Predicate != null))
          {
            tmp203.Predicate = (global::Apache.Cassandra.Test.SlicePredicate)this.Predicate.DeepCopy();
          }
          if((Range != null))
          {
            tmp203.Range = (global::Apache.Cassandra.Test.KeyRange)this.Range.DeepCopy();
          }
          tmp203.Consistency_level = this.Consistency_level;
          return tmp203;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          try
          {
            bool isset_column_parent = false;
            bool isset_predicate = false;
            bool isset_range = false;
            bool isset_consistency_level = false;
            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)
                  {
                    Column_parent = new global::Apache.Cassandra.Test.ColumnParent();
                    await Column_parent.ReadAsync(iprot, cancellationToken);
                    isset_column_parent = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Predicate = new global::Apache.Cassandra.Test.SlicePredicate();
                    await Predicate.ReadAsync(iprot, cancellationToken);
                    isset_predicate = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Range = new global::Apache.Cassandra.Test.KeyRange();
                    await Range.ReadAsync(iprot, cancellationToken);
                    isset_range = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.I32)
                  {
                    Consistency_level = (global::Apache.Cassandra.Test.ConsistencyLevel)await iprot.ReadI32Async(cancellationToken);
                    isset_consistency_level = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_column_parent)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_predicate)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_range)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_consistency_level)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("get_range_slices_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Column_parent != null))
            {
              field.Name = "column_parent";
              field.Type = TType.Struct;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column_parent.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Predicate != null))
            {
              field.Name = "predicate";
              field.Type = TType.Struct;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Predicate.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Range != null))
            {
              field.Name = "range";
              field.Type = TType.Struct;
              field.ID = 3;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Range.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "consistency_level";
            field.Type = TType.I32;
            field.ID = 4;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Consistency_level, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is get_range_slicesArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Column_parent, other.Column_parent)
            && System.Object.Equals(Predicate, other.Predicate)
            && System.Object.Equals(Range, other.Range)
            && System.Object.Equals(Consistency_level, other.Consistency_level);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Column_parent != null))
            {
              hashcode = (hashcode * 397) + Column_parent.GetHashCode();
            }
            if((Predicate != null))
            {
              hashcode = (hashcode * 397) + Predicate.GetHashCode();
            }
            if((Range != null))
            {
              hashcode = (hashcode * 397) + Range.GetHashCode();
            }
            hashcode = (hashcode * 397) + Consistency_level.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("get_range_slices_args(");
          if((Column_parent != null))
          {
            sb.Append(", Column_parent: ");
            Column_parent.ToString(sb);
          }
          if((Predicate != null))
          {
            sb.Append(", Predicate: ");
            Predicate.ToString(sb);
          }
          if((Range != null))
          {
            sb.Append(", Range: ");
            Range.ToString(sb);
          }
          sb.Append(", Consistency_level: ");
          Consistency_level.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class get_range_slicesResult : TBase
      {
        private List<global::Apache.Cassandra.Test.KeySlice> _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public List<global::Apache.Cassandra.Test.KeySlice> Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public get_range_slicesResult()
        {
        }

        public get_range_slicesResult DeepCopy()
        {
          var tmp205 = new get_range_slicesResult();
          if((Success != null) && __isset.success)
          {
            tmp205.Success = this.Success.DeepCopy();
          }
          tmp205.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp205.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp205.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp205.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp205.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp205.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp205.__isset.te = this.__isset.te;
          return tmp205;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.List)
                  {
                    {
                      TList _list206 = await iprot.ReadListBeginAsync(cancellationToken);
                      Success = new List<global::Apache.Cassandra.Test.KeySlice>(_list206.Count);
                      for(int _i207 = 0; _i207 < _list206.Count; ++_i207)
                      {
                        global::Apache.Cassandra.Test.KeySlice _elem208;
                        _elem208 = new global::Apache.Cassandra.Test.KeySlice();
                        await _elem208.ReadAsync(iprot, cancellationToken);
                        Success.Add(_elem208);
                      }
                      await iprot.ReadListEndAsync(cancellationToken);
                    }
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.List;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                {
                  await oprot.WriteListBeginAsync(new TList(TType.Struct, Success.Count), cancellationToken);
                  foreach (global::Apache.Cassandra.Test.KeySlice _iter209 in Success)
                  {
                    await _iter209.WriteAsync(oprot, cancellationToken);
                  }
                  await oprot.WriteListEndAsync(cancellationToken);
                }
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is get_range_slicesResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.success == other.__isset.success) && ((!__isset.success) || (TCollections.Equals(Success, other.Success))))
            && ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Success != null) && __isset.success)
            {
              hashcode = (hashcode * 397) + TCollections.GetHashCode(Success);
            }
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("get_range_slices_result(");
          int tmp210 = 0;
          if((Success != null) && __isset.success)
          {
            if(0 < tmp210++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp210++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp210++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp210++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class get_indexed_slicesArgs : TBase
      {

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ColumnParent Column_parent { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.IndexClause Index_clause { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SlicePredicate Column_predicate { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.ConsistencyLevel"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ConsistencyLevel Consistency_level { get; set; }

        public get_indexed_slicesArgs()
        {
          this.Consistency_level = global::Apache.Cassandra.Test.ConsistencyLevel.ONE;
        }

        public get_indexed_slicesArgs(global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.IndexClause index_clause, global::Apache.Cassandra.Test.SlicePredicate column_predicate, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level) : this()
        {
          this.Column_parent = column_parent;
          this.Index_clause = index_clause;
          this.Column_predicate = column_predicate;
          this.Consistency_level = consistency_level;
        }

        public get_indexed_slicesArgs DeepCopy()
        {
          var tmp211 = new get_indexed_slicesArgs();
          if((Column_parent != null))
          {
            tmp211.Column_parent = (global::Apache.Cassandra.Test.ColumnParent)this.Column_parent.DeepCopy();
          }
          if((Index_clause != null))
          {
            tmp211.Index_clause = (global::Apache.Cassandra.Test.IndexClause)this.Index_clause.DeepCopy();
          }
          if((Column_predicate != null))
          {
            tmp211.Column_predicate = (global::Apache.Cassandra.Test.SlicePredicate)this.Column_predicate.DeepCopy();
          }
          tmp211.Consistency_level = this.Consistency_level;
          return tmp211;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          try
          {
            bool isset_column_parent = false;
            bool isset_index_clause = false;
            bool isset_column_predicate = false;
            bool isset_consistency_level = false;
            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)
                  {
                    Column_parent = new global::Apache.Cassandra.Test.ColumnParent();
                    await Column_parent.ReadAsync(iprot, cancellationToken);
                    isset_column_parent = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Index_clause = new global::Apache.Cassandra.Test.IndexClause();
                    await Index_clause.ReadAsync(iprot, cancellationToken);
                    isset_index_clause = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Column_predicate = new global::Apache.Cassandra.Test.SlicePredicate();
                    await Column_predicate.ReadAsync(iprot, cancellationToken);
                    isset_column_predicate = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.I32)
                  {
                    Consistency_level = (global::Apache.Cassandra.Test.ConsistencyLevel)await iprot.ReadI32Async(cancellationToken);
                    isset_consistency_level = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_column_parent)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_index_clause)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_column_predicate)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_consistency_level)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("get_indexed_slices_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Column_parent != null))
            {
              field.Name = "column_parent";
              field.Type = TType.Struct;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column_parent.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Index_clause != null))
            {
              field.Name = "index_clause";
              field.Type = TType.Struct;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Index_clause.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Column_predicate != null))
            {
              field.Name = "column_predicate";
              field.Type = TType.Struct;
              field.ID = 3;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column_predicate.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "consistency_level";
            field.Type = TType.I32;
            field.ID = 4;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Consistency_level, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is get_indexed_slicesArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Column_parent, other.Column_parent)
            && System.Object.Equals(Index_clause, other.Index_clause)
            && System.Object.Equals(Column_predicate, other.Column_predicate)
            && System.Object.Equals(Consistency_level, other.Consistency_level);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Column_parent != null))
            {
              hashcode = (hashcode * 397) + Column_parent.GetHashCode();
            }
            if((Index_clause != null))
            {
              hashcode = (hashcode * 397) + Index_clause.GetHashCode();
            }
            if((Column_predicate != null))
            {
              hashcode = (hashcode * 397) + Column_predicate.GetHashCode();
            }
            hashcode = (hashcode * 397) + Consistency_level.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("get_indexed_slices_args(");
          if((Column_parent != null))
          {
            sb.Append(", Column_parent: ");
            Column_parent.ToString(sb);
          }
          if((Index_clause != null))
          {
            sb.Append(", Index_clause: ");
            Index_clause.ToString(sb);
          }
          if((Column_predicate != null))
          {
            sb.Append(", Column_predicate: ");
            Column_predicate.ToString(sb);
          }
          sb.Append(", Consistency_level: ");
          Consistency_level.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class get_indexed_slicesResult : TBase
      {
        private List<global::Apache.Cassandra.Test.KeySlice> _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public List<global::Apache.Cassandra.Test.KeySlice> Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public get_indexed_slicesResult()
        {
        }

        public get_indexed_slicesResult DeepCopy()
        {
          var tmp213 = new get_indexed_slicesResult();
          if((Success != null) && __isset.success)
          {
            tmp213.Success = this.Success.DeepCopy();
          }
          tmp213.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp213.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp213.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp213.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp213.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp213.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp213.__isset.te = this.__isset.te;
          return tmp213;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.List)
                  {
                    {
                      TList _list214 = await iprot.ReadListBeginAsync(cancellationToken);
                      Success = new List<global::Apache.Cassandra.Test.KeySlice>(_list214.Count);
                      for(int _i215 = 0; _i215 < _list214.Count; ++_i215)
                      {
                        global::Apache.Cassandra.Test.KeySlice _elem216;
                        _elem216 = new global::Apache.Cassandra.Test.KeySlice();
                        await _elem216.ReadAsync(iprot, cancellationToken);
                        Success.Add(_elem216);
                      }
                      await iprot.ReadListEndAsync(cancellationToken);
                    }
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.List;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                {
                  await oprot.WriteListBeginAsync(new TList(TType.Struct, Success.Count), cancellationToken);
                  foreach (global::Apache.Cassandra.Test.KeySlice _iter217 in Success)
                  {
                    await _iter217.WriteAsync(oprot, cancellationToken);
                  }
                  await oprot.WriteListEndAsync(cancellationToken);
                }
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is get_indexed_slicesResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.success == other.__isset.success) && ((!__isset.success) || (TCollections.Equals(Success, other.Success))))
            && ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Success != null) && __isset.success)
            {
              hashcode = (hashcode * 397) + TCollections.GetHashCode(Success);
            }
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("get_indexed_slices_result(");
          int tmp218 = 0;
          if((Success != null) && __isset.success)
          {
            if(0 < tmp218++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp218++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp218++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp218++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class insertArgs : TBase
      {

        [DataMember(Order = 0)]
        public byte[] Key { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ColumnParent Column_parent { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.Column Column { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.ConsistencyLevel"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ConsistencyLevel Consistency_level { get; set; }

        public insertArgs()
        {
          this.Consistency_level = global::Apache.Cassandra.Test.ConsistencyLevel.ONE;
        }

        public insertArgs(byte[] key, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.Column column, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level) : this()
        {
          this.Key = key;
          this.Column_parent = column_parent;
          this.Column = column;
          this.Consistency_level = consistency_level;
        }

        public insertArgs DeepCopy()
        {
          var tmp219 = new insertArgs();
          if((Key != null))
          {
            tmp219.Key = this.Key.ToArray();
          }
          if((Column_parent != null))
          {
            tmp219.Column_parent = (global::Apache.Cassandra.Test.ColumnParent)this.Column_parent.DeepCopy();
          }
          if((Column != null))
          {
            tmp219.Column = (global::Apache.Cassandra.Test.Column)this.Column.DeepCopy();
          }
          tmp219.Consistency_level = this.Consistency_level;
          return tmp219;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Key = await iprot.ReadBinaryAsync(cancellationToken);
                    isset_key = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Column_parent = new global::Apache.Cassandra.Test.ColumnParent();
                    await Column_parent.ReadAsync(iprot, cancellationToken);
                    isset_column_parent = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Column = new global::Apache.Cassandra.Test.Column();
                    await Column.ReadAsync(iprot, cancellationToken);
                    isset_column = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.I32)
                  {
                    Consistency_level = (global::Apache.Cassandra.Test.ConsistencyLevel)await iprot.ReadI32Async(cancellationToken);
                    isset_consistency_level = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_key)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_column_parent)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_column)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_consistency_level)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("insert_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Key != null))
            {
              field.Name = "key";
              field.Type = TType.String;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteBinaryAsync(Key, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Column_parent != null))
            {
              field.Name = "column_parent";
              field.Type = TType.Struct;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column_parent.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Column != null))
            {
              field.Name = "column";
              field.Type = TType.Struct;
              field.ID = 3;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "consistency_level";
            field.Type = TType.I32;
            field.ID = 4;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Consistency_level, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is insertArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return TCollections.Equals(Key, other.Key)
            && System.Object.Equals(Column_parent, other.Column_parent)
            && System.Object.Equals(Column, other.Column)
            && System.Object.Equals(Consistency_level, other.Consistency_level);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Key != null))
            {
              hashcode = (hashcode * 397) + Key.GetHashCode();
            }
            if((Column_parent != null))
            {
              hashcode = (hashcode * 397) + Column_parent.GetHashCode();
            }
            if((Column != null))
            {
              hashcode = (hashcode * 397) + Column.GetHashCode();
            }
            hashcode = (hashcode * 397) + Consistency_level.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("insert_args(");
          if((Key != null))
          {
            sb.Append(", Key: ");
            Key.ToString(sb);
          }
          if((Column_parent != null))
          {
            sb.Append(", Column_parent: ");
            Column_parent.ToString(sb);
          }
          if((Column != null))
          {
            sb.Append(", Column: ");
            Column.ToString(sb);
          }
          sb.Append(", Consistency_level: ");
          Consistency_level.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class insertResult : TBase
      {
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public insertResult()
        {
        }

        public insertResult DeepCopy()
        {
          var tmp221 = new insertResult();
          if((Ire != null) && __isset.ire)
          {
            tmp221.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp221.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp221.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp221.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp221.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp221.__isset.te = this.__isset.te;
          return tmp221;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is insertResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("insert_result(");
          int tmp222 = 0;
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp222++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp222++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp222++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class addArgs : TBase
      {

        [DataMember(Order = 0)]
        public byte[] Key { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ColumnParent Column_parent { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.CounterColumn Column { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.ConsistencyLevel"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ConsistencyLevel Consistency_level { get; set; }

        public addArgs()
        {
          this.Consistency_level = global::Apache.Cassandra.Test.ConsistencyLevel.ONE;
        }

        public addArgs(byte[] key, global::Apache.Cassandra.Test.ColumnParent column_parent, global::Apache.Cassandra.Test.CounterColumn column, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level) : this()
        {
          this.Key = key;
          this.Column_parent = column_parent;
          this.Column = column;
          this.Consistency_level = consistency_level;
        }

        public addArgs DeepCopy()
        {
          var tmp223 = new addArgs();
          if((Key != null))
          {
            tmp223.Key = this.Key.ToArray();
          }
          if((Column_parent != null))
          {
            tmp223.Column_parent = (global::Apache.Cassandra.Test.ColumnParent)this.Column_parent.DeepCopy();
          }
          if((Column != null))
          {
            tmp223.Column = (global::Apache.Cassandra.Test.CounterColumn)this.Column.DeepCopy();
          }
          tmp223.Consistency_level = this.Consistency_level;
          return tmp223;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Key = await iprot.ReadBinaryAsync(cancellationToken);
                    isset_key = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Column_parent = new global::Apache.Cassandra.Test.ColumnParent();
                    await Column_parent.ReadAsync(iprot, cancellationToken);
                    isset_column_parent = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Column = new global::Apache.Cassandra.Test.CounterColumn();
                    await Column.ReadAsync(iprot, cancellationToken);
                    isset_column = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.I32)
                  {
                    Consistency_level = (global::Apache.Cassandra.Test.ConsistencyLevel)await iprot.ReadI32Async(cancellationToken);
                    isset_consistency_level = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_key)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_column_parent)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_column)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_consistency_level)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("add_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Key != null))
            {
              field.Name = "key";
              field.Type = TType.String;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteBinaryAsync(Key, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Column_parent != null))
            {
              field.Name = "column_parent";
              field.Type = TType.Struct;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column_parent.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Column != null))
            {
              field.Name = "column";
              field.Type = TType.Struct;
              field.ID = 3;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "consistency_level";
            field.Type = TType.I32;
            field.ID = 4;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Consistency_level, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is addArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return TCollections.Equals(Key, other.Key)
            && System.Object.Equals(Column_parent, other.Column_parent)
            && System.Object.Equals(Column, other.Column)
            && System.Object.Equals(Consistency_level, other.Consistency_level);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Key != null))
            {
              hashcode = (hashcode * 397) + Key.GetHashCode();
            }
            if((Column_parent != null))
            {
              hashcode = (hashcode * 397) + Column_parent.GetHashCode();
            }
            if((Column != null))
            {
              hashcode = (hashcode * 397) + Column.GetHashCode();
            }
            hashcode = (hashcode * 397) + Consistency_level.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("add_args(");
          if((Key != null))
          {
            sb.Append(", Key: ");
            Key.ToString(sb);
          }
          if((Column_parent != null))
          {
            sb.Append(", Column_parent: ");
            Column_parent.ToString(sb);
          }
          if((Column != null))
          {
            sb.Append(", Column: ");
            Column.ToString(sb);
          }
          sb.Append(", Consistency_level: ");
          Consistency_level.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class addResult : TBase
      {
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public addResult()
        {
        }

        public addResult DeepCopy()
        {
          var tmp225 = new addResult();
          if((Ire != null) && __isset.ire)
          {
            tmp225.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp225.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp225.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp225.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp225.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp225.__isset.te = this.__isset.te;
          return tmp225;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is addResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("add_result(");
          int tmp226 = 0;
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp226++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp226++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp226++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class removeArgs : TBase
      {
        private global::Apache.Cassandra.Test.ConsistencyLevel _consistency_level;

        [DataMember(Order = 0)]
        public byte[] Key { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ColumnPath Column_path { get; set; }

        [DataMember(Order = 0)]
        public long Timestamp { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.ConsistencyLevel"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ConsistencyLevel Consistency_level
        {
          get
          {
            return _consistency_level;
          }
          set
          {
            __isset.consistency_level = true;
            this._consistency_level = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool consistency_level;
        }

        #region XmlSerializer support

        public bool ShouldSerializeConsistency_level()
        {
          return __isset.consistency_level;
        }

        #endregion XmlSerializer support

        public removeArgs()
        {
          this._consistency_level = global::Apache.Cassandra.Test.ConsistencyLevel.ONE;
          this.__isset.consistency_level = true;
        }

        public removeArgs(byte[] key, global::Apache.Cassandra.Test.ColumnPath column_path, long timestamp) : this()
        {
          this.Key = key;
          this.Column_path = column_path;
          this.Timestamp = timestamp;
        }

        public removeArgs DeepCopy()
        {
          var tmp227 = new removeArgs();
          if((Key != null))
          {
            tmp227.Key = this.Key.ToArray();
          }
          if((Column_path != null))
          {
            tmp227.Column_path = (global::Apache.Cassandra.Test.ColumnPath)this.Column_path.DeepCopy();
          }
          tmp227.Timestamp = this.Timestamp;
          if(__isset.consistency_level)
          {
            tmp227.Consistency_level = this.Consistency_level;
          }
          tmp227.__isset.consistency_level = this.__isset.consistency_level;
          return tmp227;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Key = await iprot.ReadBinaryAsync(cancellationToken);
                    isset_key = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Column_path = new global::Apache.Cassandra.Test.ColumnPath();
                    await Column_path.ReadAsync(iprot, cancellationToken);
                    isset_column_path = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.I64)
                  {
                    Timestamp = await iprot.ReadI64Async(cancellationToken);
                    isset_timestamp = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.I32)
                  {
                    Consistency_level = (global::Apache.Cassandra.Test.ConsistencyLevel)await iprot.ReadI32Async(cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_key)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_column_path)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_timestamp)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("remove_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Key != null))
            {
              field.Name = "key";
              field.Type = TType.String;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteBinaryAsync(Key, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Column_path != null))
            {
              field.Name = "column_path";
              field.Type = TType.Struct;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Column_path.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "timestamp";
            field.Type = TType.I64;
            field.ID = 3;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI64Async(Timestamp, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            if(__isset.consistency_level)
            {
              field.Name = "consistency_level";
              field.Type = TType.I32;
              field.ID = 4;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteI32Async((int)Consistency_level, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is removeArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return TCollections.Equals(Key, other.Key)
            && System.Object.Equals(Column_path, other.Column_path)
            && System.Object.Equals(Timestamp, other.Timestamp)
            && ((__isset.consistency_level == other.__isset.consistency_level) && ((!__isset.consistency_level) || (System.Object.Equals(Consistency_level, other.Consistency_level))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Key != null))
            {
              hashcode = (hashcode * 397) + Key.GetHashCode();
            }
            if((Column_path != null))
            {
              hashcode = (hashcode * 397) + Column_path.GetHashCode();
            }
            hashcode = (hashcode * 397) + Timestamp.GetHashCode();
            if(__isset.consistency_level)
            {
              hashcode = (hashcode * 397) + Consistency_level.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("remove_args(");
          if((Key != null))
          {
            sb.Append(", Key: ");
            Key.ToString(sb);
          }
          if((Column_path != null))
          {
            sb.Append(", Column_path: ");
            Column_path.ToString(sb);
          }
          sb.Append(", Timestamp: ");
          Timestamp.ToString(sb);
          if(__isset.consistency_level)
          {
            sb.Append(", Consistency_level: ");
            Consistency_level.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class removeResult : TBase
      {
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public removeResult()
        {
        }

        public removeResult DeepCopy()
        {
          var tmp229 = new removeResult();
          if((Ire != null) && __isset.ire)
          {
            tmp229.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp229.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp229.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp229.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp229.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp229.__isset.te = this.__isset.te;
          return tmp229;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is removeResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("remove_result(");
          int tmp230 = 0;
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp230++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp230++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp230++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class remove_counterArgs : TBase
      {

        [DataMember(Order = 0)]
        public byte[] Key { get; set; }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ColumnPath Path { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.ConsistencyLevel"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ConsistencyLevel Consistency_level { get; set; }

        public remove_counterArgs()
        {
          this.Consistency_level = global::Apache.Cassandra.Test.ConsistencyLevel.ONE;
        }

        public remove_counterArgs(byte[] key, global::Apache.Cassandra.Test.ColumnPath path, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level) : this()
        {
          this.Key = key;
          this.Path = path;
          this.Consistency_level = consistency_level;
        }

        public remove_counterArgs DeepCopy()
        {
          var tmp231 = new remove_counterArgs();
          if((Key != null))
          {
            tmp231.Key = this.Key.ToArray();
          }
          if((Path != null))
          {
            tmp231.Path = (global::Apache.Cassandra.Test.ColumnPath)this.Path.DeepCopy();
          }
          tmp231.Consistency_level = this.Consistency_level;
          return tmp231;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Key = await iprot.ReadBinaryAsync(cancellationToken);
                    isset_key = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Path = new global::Apache.Cassandra.Test.ColumnPath();
                    await Path.ReadAsync(iprot, cancellationToken);
                    isset_path = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.I32)
                  {
                    Consistency_level = (global::Apache.Cassandra.Test.ConsistencyLevel)await iprot.ReadI32Async(cancellationToken);
                    isset_consistency_level = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_key)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_path)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_consistency_level)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("remove_counter_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Key != null))
            {
              field.Name = "key";
              field.Type = TType.String;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteBinaryAsync(Key, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Path != null))
            {
              field.Name = "path";
              field.Type = TType.Struct;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await Path.WriteAsync(oprot, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "consistency_level";
            field.Type = TType.I32;
            field.ID = 3;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Consistency_level, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is remove_counterArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return TCollections.Equals(Key, other.Key)
            && System.Object.Equals(Path, other.Path)
            && System.Object.Equals(Consistency_level, other.Consistency_level);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Key != null))
            {
              hashcode = (hashcode * 397) + Key.GetHashCode();
            }
            if((Path != null))
            {
              hashcode = (hashcode * 397) + Path.GetHashCode();
            }
            hashcode = (hashcode * 397) + Consistency_level.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("remove_counter_args(");
          if((Key != null))
          {
            sb.Append(", Key: ");
            Key.ToString(sb);
          }
          if((Path != null))
          {
            sb.Append(", Path: ");
            Path.ToString(sb);
          }
          sb.Append(", Consistency_level: ");
          Consistency_level.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class remove_counterResult : TBase
      {
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public remove_counterResult()
        {
        }

        public remove_counterResult DeepCopy()
        {
          var tmp233 = new remove_counterResult();
          if((Ire != null) && __isset.ire)
          {
            tmp233.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp233.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp233.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp233.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp233.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp233.__isset.te = this.__isset.te;
          return tmp233;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is remove_counterResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("remove_counter_result(");
          int tmp234 = 0;
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp234++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp234++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp234++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class batch_mutateArgs : TBase
      {

        [DataMember(Order = 0)]
        public Dictionary<byte[], Dictionary<string, List<global::Apache.Cassandra.Test.Mutation>>> Mutation_map { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.ConsistencyLevel"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.ConsistencyLevel Consistency_level { get; set; }

        public batch_mutateArgs()
        {
          this.Consistency_level = global::Apache.Cassandra.Test.ConsistencyLevel.ONE;
        }

        public batch_mutateArgs(Dictionary<byte[], Dictionary<string, List<global::Apache.Cassandra.Test.Mutation>>> mutation_map, global::Apache.Cassandra.Test.ConsistencyLevel consistency_level) : this()
        {
          this.Mutation_map = mutation_map;
          this.Consistency_level = consistency_level;
        }

        public batch_mutateArgs DeepCopy()
        {
          var tmp235 = new batch_mutateArgs();
          if((Mutation_map != null))
          {
            tmp235.Mutation_map = this.Mutation_map.DeepCopy();
          }
          tmp235.Consistency_level = this.Consistency_level;
          return tmp235;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          try
          {
            bool isset_mutation_map = false;
            bool isset_consistency_level = false;
            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.Map)
                  {
                    {
                      TMap _map236 = await iprot.ReadMapBeginAsync(cancellationToken);
                      Mutation_map = new Dictionary<byte[], Dictionary<string, List<global::Apache.Cassandra.Test.Mutation>>>(_map236.Count);
                      for(int _i237 = 0; _i237 < _map236.Count; ++_i237)
                      {
                        byte[] _key238;
                        Dictionary<string, List<global::Apache.Cassandra.Test.Mutation>> _val239;
                        _key238 = await iprot.ReadBinaryAsync(cancellationToken);
                        {
                          TMap _map240 = await iprot.ReadMapBeginAsync(cancellationToken);
                          _val239 = new Dictionary<string, List<global::Apache.Cassandra.Test.Mutation>>(_map240.Count);
                          for(int _i241 = 0; _i241 < _map240.Count; ++_i241)
                          {
                            string _key242;
                            List<global::Apache.Cassandra.Test.Mutation> _val243;
                            _key242 = await iprot.ReadStringAsync(cancellationToken);
                            {
                              TList _list244 = await iprot.ReadListBeginAsync(cancellationToken);
                              _val243 = new List<global::Apache.Cassandra.Test.Mutation>(_list244.Count);
                              for(int _i245 = 0; _i245 < _list244.Count; ++_i245)
                              {
                                global::Apache.Cassandra.Test.Mutation _elem246;
                                _elem246 = new global::Apache.Cassandra.Test.Mutation();
                                await _elem246.ReadAsync(iprot, cancellationToken);
                                _val243.Add(_elem246);
                              }
                              await iprot.ReadListEndAsync(cancellationToken);
                            }
                            _val239[_key242] = _val243;
                          }
                          await iprot.ReadMapEndAsync(cancellationToken);
                        }
                        Mutation_map[_key238] = _val239;
                      }
                      await iprot.ReadMapEndAsync(cancellationToken);
                    }
                    isset_mutation_map = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.I32)
                  {
                    Consistency_level = (global::Apache.Cassandra.Test.ConsistencyLevel)await iprot.ReadI32Async(cancellationToken);
                    isset_consistency_level = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_mutation_map)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_consistency_level)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("batch_mutate_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Mutation_map != null))
            {
              field.Name = "mutation_map";
              field.Type = TType.Map;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              {
                await oprot.WriteMapBeginAsync(new TMap(TType.String, TType.Map, Mutation_map.Count), cancellationToken);
                foreach (byte[] _iter247 in Mutation_map.Keys)
                {
                  await oprot.WriteBinaryAsync(_iter247, cancellationToken);
                  {
                    await oprot.WriteMapBeginAsync(new TMap(TType.String, TType.List, Mutation_map[_iter247].Count), cancellationToken);
                    foreach (string _iter248 in Mutation_map[_iter247].Keys)
                    {
                      await oprot.WriteStringAsync(_iter248, cancellationToken);
                      {
                        await oprot.WriteListBeginAsync(new TList(TType.Struct, Mutation_map[_iter247][_iter248].Count), cancellationToken);
                        foreach (global::Apache.Cassandra.Test.Mutation _iter249 in Mutation_map[_iter247][_iter248])
                        {
                          await _iter249.WriteAsync(oprot, cancellationToken);
                        }
                        await oprot.WriteListEndAsync(cancellationToken);
                      }
                    }
                    await oprot.WriteMapEndAsync(cancellationToken);
                  }
                }
                await oprot.WriteMapEndAsync(cancellationToken);
              }
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "consistency_level";
            field.Type = TType.I32;
            field.ID = 2;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Consistency_level, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is batch_mutateArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return TCollections.Equals(Mutation_map, other.Mutation_map)
            && System.Object.Equals(Consistency_level, other.Consistency_level);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Mutation_map != null))
            {
              hashcode = (hashcode * 397) + TCollections.GetHashCode(Mutation_map);
            }
            hashcode = (hashcode * 397) + Consistency_level.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("batch_mutate_args(");
          if((Mutation_map != null))
          {
            sb.Append(", Mutation_map: ");
            Mutation_map.ToString(sb);
          }
          sb.Append(", Consistency_level: ");
          Consistency_level.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class batch_mutateResult : TBase
      {
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public batch_mutateResult()
        {
        }

        public batch_mutateResult DeepCopy()
        {
          var tmp251 = new batch_mutateResult();
          if((Ire != null) && __isset.ire)
          {
            tmp251.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp251.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp251.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp251.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp251.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp251.__isset.te = this.__isset.te;
          return tmp251;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is batch_mutateResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("batch_mutate_result(");
          int tmp252 = 0;
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp252++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp252++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp252++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class truncateArgs : TBase
      {

        [DataMember(Order = 0)]
        public string Cfname { get; set; }

        public truncateArgs()
        {
        }

        public truncateArgs(string cfname) : this()
        {
          this.Cfname = cfname;
        }

        public truncateArgs DeepCopy()
        {
          var tmp253 = new truncateArgs();
          if((Cfname != null))
          {
            tmp253.Cfname = this.Cfname;
          }
          return tmp253;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Cfname = await iprot.ReadStringAsync(cancellationToken);
                    isset_cfname = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_cfname)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

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

        public override bool Equals(object that)
        {
          if (!(that is truncateArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Cfname, other.Cfname);
        }

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

        public override string ToString()
        {
          var sb = new StringBuilder("truncate_args(");
          if((Cfname != null))
          {
            sb.Append(", Cfname: ");
            Cfname.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class truncateResult : TBase
      {
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
        }

        #region XmlSerializer support

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        #endregion XmlSerializer support

        public truncateResult()
        {
        }

        public truncateResult DeepCopy()
        {
          var tmp255 = new truncateResult();
          if((Ire != null) && __isset.ire)
          {
            tmp255.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp255.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp255.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp255.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp255.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp255.__isset.te = this.__isset.te;
          return tmp255;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is truncateResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("truncate_result(");
          int tmp256 = 0;
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp256++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp256++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp256++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_schema_versionsArgs : TBase
      {

        public describe_schema_versionsArgs()
        {
        }

        public describe_schema_versionsArgs DeepCopy()
        {
          var tmp257 = new describe_schema_versionsArgs();
          return tmp257;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.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("describe_schema_versions_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 describe_schema_versionsArgs 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("describe_schema_versions_args(");
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_schema_versionsResult : TBase
      {
        private Dictionary<string, List<string>> _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;

        [DataMember(Order = 0)]
        public Dictionary<string, List<string>> Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        #endregion XmlSerializer support

        public describe_schema_versionsResult()
        {
        }

        public describe_schema_versionsResult DeepCopy()
        {
          var tmp259 = new describe_schema_versionsResult();
          if((Success != null) && __isset.success)
          {
            tmp259.Success = this.Success.DeepCopy();
          }
          tmp259.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp259.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp259.__isset.ire = this.__isset.ire;
          return tmp259;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.Map)
                  {
                    {
                      TMap _map260 = await iprot.ReadMapBeginAsync(cancellationToken);
                      Success = new Dictionary<string, List<string>>(_map260.Count);
                      for(int _i261 = 0; _i261 < _map260.Count; ++_i261)
                      {
                        string _key262;
                        List<string> _val263;
                        _key262 = await iprot.ReadStringAsync(cancellationToken);
                        {
                          TList _list264 = await iprot.ReadListBeginAsync(cancellationToken);
                          _val263 = new List<string>(_list264.Count);
                          for(int _i265 = 0; _i265 < _list264.Count; ++_i265)
                          {
                            string _elem266;
                            _elem266 = await iprot.ReadStringAsync(cancellationToken);
                            _val263.Add(_elem266);
                          }
                          await iprot.ReadListEndAsync(cancellationToken);
                        }
                        Success[_key262] = _val263;
                      }
                      await iprot.ReadMapEndAsync(cancellationToken);
                    }
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.Map;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                {
                  await oprot.WriteMapBeginAsync(new TMap(TType.String, TType.List, Success.Count), cancellationToken);
                  foreach (string _iter267 in Success.Keys)
                  {
                    await oprot.WriteStringAsync(_iter267, cancellationToken);
                    {
                      await oprot.WriteListBeginAsync(new TList(TType.String, Success[_iter267].Count), cancellationToken);
                      foreach (string _iter268 in Success[_iter267])
                      {
                        await oprot.WriteStringAsync(_iter268, cancellationToken);
                      }
                      await oprot.WriteListEndAsync(cancellationToken);
                    }
                  }
                  await oprot.WriteMapEndAsync(cancellationToken);
                }
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

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

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

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


      [DataContract(Namespace="")]
      public partial class describe_keyspacesArgs : TBase
      {

        public describe_keyspacesArgs()
        {
        }

        public describe_keyspacesArgs DeepCopy()
        {
          var tmp270 = new describe_keyspacesArgs();
          return tmp270;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.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("describe_keyspaces_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 describe_keyspacesArgs 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("describe_keyspaces_args(");
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_keyspacesResult : TBase
      {
        private List<global::Apache.Cassandra.Test.KsDef> _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;

        [DataMember(Order = 0)]
        public List<global::Apache.Cassandra.Test.KsDef> Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        #endregion XmlSerializer support

        public describe_keyspacesResult()
        {
        }

        public describe_keyspacesResult DeepCopy()
        {
          var tmp272 = new describe_keyspacesResult();
          if((Success != null) && __isset.success)
          {
            tmp272.Success = this.Success.DeepCopy();
          }
          tmp272.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp272.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp272.__isset.ire = this.__isset.ire;
          return tmp272;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.List)
                  {
                    {
                      TList _list273 = await iprot.ReadListBeginAsync(cancellationToken);
                      Success = new List<global::Apache.Cassandra.Test.KsDef>(_list273.Count);
                      for(int _i274 = 0; _i274 < _list273.Count; ++_i274)
                      {
                        global::Apache.Cassandra.Test.KsDef _elem275;
                        _elem275 = new global::Apache.Cassandra.Test.KsDef();
                        await _elem275.ReadAsync(iprot, cancellationToken);
                        Success.Add(_elem275);
                      }
                      await iprot.ReadListEndAsync(cancellationToken);
                    }
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.List;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                {
                  await oprot.WriteListBeginAsync(new TList(TType.Struct, Success.Count), cancellationToken);
                  foreach (global::Apache.Cassandra.Test.KsDef _iter276 in Success)
                  {
                    await _iter276.WriteAsync(oprot, cancellationToken);
                  }
                  await oprot.WriteListEndAsync(cancellationToken);
                }
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

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

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

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


      [DataContract(Namespace="")]
      public partial class describe_cluster_nameArgs : TBase
      {

        public describe_cluster_nameArgs()
        {
        }

        public describe_cluster_nameArgs DeepCopy()
        {
          var tmp278 = new describe_cluster_nameArgs();
          return tmp278;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.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("describe_cluster_name_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 describe_cluster_nameArgs 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("describe_cluster_name_args(");
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_cluster_nameResult : TBase
      {
        private string _success;

        [DataMember(Order = 0)]
        public string Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        #endregion XmlSerializer support

        public describe_cluster_nameResult()
        {
        }

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

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.String)
                  {
                    Success = 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("describe_cluster_name_result");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.String;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await oprot.WriteStringAsync(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 describe_cluster_nameResult 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("describe_cluster_name_result(");
          int tmp281 = 0;
          if((Success != null) && __isset.success)
          {
            if(0 < tmp281++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_versionArgs : TBase
      {

        public describe_versionArgs()
        {
        }

        public describe_versionArgs DeepCopy()
        {
          var tmp282 = new describe_versionArgs();
          return tmp282;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.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("describe_version_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 describe_versionArgs 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("describe_version_args(");
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_versionResult : TBase
      {
        private string _success;

        [DataMember(Order = 0)]
        public string Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        #endregion XmlSerializer support

        public describe_versionResult()
        {
        }

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

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.String)
                  {
                    Success = 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("describe_version_result");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.String;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await oprot.WriteStringAsync(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 describe_versionResult 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("describe_version_result(");
          int tmp285 = 0;
          if((Success != null) && __isset.success)
          {
            if(0 < tmp285++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_ringArgs : TBase
      {

        [DataMember(Order = 0)]
        public string Keyspace { get; set; }

        public describe_ringArgs()
        {
        }

        public describe_ringArgs(string keyspace) : this()
        {
          this.Keyspace = keyspace;
        }

        public describe_ringArgs DeepCopy()
        {
          var tmp286 = new describe_ringArgs();
          if((Keyspace != null))
          {
            tmp286.Keyspace = this.Keyspace;
          }
          return tmp286;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Keyspace = await iprot.ReadStringAsync(cancellationToken);
                    isset_keyspace = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_keyspace)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

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

        public override bool Equals(object that)
        {
          if (!(that is describe_ringArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Keyspace, other.Keyspace);
        }

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

        public override string ToString()
        {
          var sb = new StringBuilder("describe_ring_args(");
          if((Keyspace != null))
          {
            sb.Append(", Keyspace: ");
            Keyspace.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_ringResult : TBase
      {
        private List<global::Apache.Cassandra.Test.TokenRange> _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;

        [DataMember(Order = 0)]
        public List<global::Apache.Cassandra.Test.TokenRange> Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        #endregion XmlSerializer support

        public describe_ringResult()
        {
        }

        public describe_ringResult DeepCopy()
        {
          var tmp288 = new describe_ringResult();
          if((Success != null) && __isset.success)
          {
            tmp288.Success = this.Success.DeepCopy();
          }
          tmp288.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp288.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp288.__isset.ire = this.__isset.ire;
          return tmp288;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.List)
                  {
                    {
                      TList _list289 = await iprot.ReadListBeginAsync(cancellationToken);
                      Success = new List<global::Apache.Cassandra.Test.TokenRange>(_list289.Count);
                      for(int _i290 = 0; _i290 < _list289.Count; ++_i290)
                      {
                        global::Apache.Cassandra.Test.TokenRange _elem291;
                        _elem291 = new global::Apache.Cassandra.Test.TokenRange();
                        await _elem291.ReadAsync(iprot, cancellationToken);
                        Success.Add(_elem291);
                      }
                      await iprot.ReadListEndAsync(cancellationToken);
                    }
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.List;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                {
                  await oprot.WriteListBeginAsync(new TList(TType.Struct, Success.Count), cancellationToken);
                  foreach (global::Apache.Cassandra.Test.TokenRange _iter292 in Success)
                  {
                    await _iter292.WriteAsync(oprot, cancellationToken);
                  }
                  await oprot.WriteListEndAsync(cancellationToken);
                }
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

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

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

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


      [DataContract(Namespace="")]
      public partial class describe_partitionerArgs : TBase
      {

        public describe_partitionerArgs()
        {
        }

        public describe_partitionerArgs DeepCopy()
        {
          var tmp294 = new describe_partitionerArgs();
          return tmp294;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.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("describe_partitioner_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 describe_partitionerArgs 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("describe_partitioner_args(");
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_partitionerResult : TBase
      {
        private string _success;

        [DataMember(Order = 0)]
        public string Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        #endregion XmlSerializer support

        public describe_partitionerResult()
        {
        }

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

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.String)
                  {
                    Success = 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("describe_partitioner_result");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.String;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await oprot.WriteStringAsync(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 describe_partitionerResult 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("describe_partitioner_result(");
          int tmp297 = 0;
          if((Success != null) && __isset.success)
          {
            if(0 < tmp297++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_snitchArgs : TBase
      {

        public describe_snitchArgs()
        {
        }

        public describe_snitchArgs DeepCopy()
        {
          var tmp298 = new describe_snitchArgs();
          return tmp298;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.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("describe_snitch_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 describe_snitchArgs 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("describe_snitch_args(");
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_snitchResult : TBase
      {
        private string _success;

        [DataMember(Order = 0)]
        public string Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        #endregion XmlSerializer support

        public describe_snitchResult()
        {
        }

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

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.String)
                  {
                    Success = 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("describe_snitch_result");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.String;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await oprot.WriteStringAsync(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 describe_snitchResult 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("describe_snitch_result(");
          int tmp301 = 0;
          if((Success != null) && __isset.success)
          {
            if(0 < tmp301++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_keyspaceArgs : TBase
      {

        [DataMember(Order = 0)]
        public string Keyspace { get; set; }

        public describe_keyspaceArgs()
        {
        }

        public describe_keyspaceArgs(string keyspace) : this()
        {
          this.Keyspace = keyspace;
        }

        public describe_keyspaceArgs DeepCopy()
        {
          var tmp302 = new describe_keyspaceArgs();
          if((Keyspace != null))
          {
            tmp302.Keyspace = this.Keyspace;
          }
          return tmp302;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Keyspace = await iprot.ReadStringAsync(cancellationToken);
                    isset_keyspace = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_keyspace)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

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

        public override bool Equals(object that)
        {
          if (!(that is describe_keyspaceArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Keyspace, other.Keyspace);
        }

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

        public override string ToString()
        {
          var sb = new StringBuilder("describe_keyspace_args(");
          if((Keyspace != null))
          {
            sb.Append(", Keyspace: ");
            Keyspace.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_keyspaceResult : TBase
      {
        private global::Apache.Cassandra.Test.KsDef _success;
        private global::Apache.Cassandra.Test.NotFoundException _nfe;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.KsDef Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.NotFoundException Nfe
        {
          get
          {
            return _nfe;
          }
          set
          {
            __isset.nfe = true;
            this._nfe = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool nfe;
          [DataMember]
          public bool ire;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeNfe()
        {
          return __isset.nfe;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        #endregion XmlSerializer support

        public describe_keyspaceResult()
        {
        }

        public describe_keyspaceResult DeepCopy()
        {
          var tmp304 = new describe_keyspaceResult();
          if((Success != null) && __isset.success)
          {
            tmp304.Success = (global::Apache.Cassandra.Test.KsDef)this.Success.DeepCopy();
          }
          tmp304.__isset.success = this.__isset.success;
          if((Nfe != null) && __isset.nfe)
          {
            tmp304.Nfe = (global::Apache.Cassandra.Test.NotFoundException)this.Nfe.DeepCopy();
          }
          tmp304.__isset.nfe = this.__isset.nfe;
          if((Ire != null) && __isset.ire)
          {
            tmp304.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp304.__isset.ire = this.__isset.ire;
          return tmp304;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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 global::Apache.Cassandra.Test.KsDef();
                    await Success.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Nfe = new global::Apache.Cassandra.Test.NotFoundException();
                    await Nfe.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("describe_keyspace_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);
              }
            }
            else if(this.__isset.nfe)
            {
              if (Nfe != null)
              {
                field.Name = "Nfe";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Nfe.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

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

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

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


      [DataContract(Namespace="")]
      public partial class describe_splitsArgs : TBase
      {

        [DataMember(Order = 0)]
        public string CfName { get; set; }

        [DataMember(Order = 0)]
        public string Start_token { get; set; }

        [DataMember(Order = 0)]
        public string End_token { get; set; }

        [DataMember(Order = 0)]
        public int Keys_per_split { get; set; }

        public describe_splitsArgs()
        {
        }

        public describe_splitsArgs(string cfName, string start_token, string end_token, int keys_per_split) : this()
        {
          this.CfName = cfName;
          this.Start_token = start_token;
          this.End_token = end_token;
          this.Keys_per_split = keys_per_split;
        }

        public describe_splitsArgs DeepCopy()
        {
          var tmp306 = new describe_splitsArgs();
          if((CfName != null))
          {
            tmp306.CfName = this.CfName;
          }
          if((Start_token != null))
          {
            tmp306.Start_token = this.Start_token;
          }
          if((End_token != null))
          {
            tmp306.End_token = this.End_token;
          }
          tmp306.Keys_per_split = this.Keys_per_split;
          return tmp306;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    CfName = await iprot.ReadStringAsync(cancellationToken);
                    isset_cfName = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.String)
                  {
                    Start_token = await iprot.ReadStringAsync(cancellationToken);
                    isset_start_token = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.String)
                  {
                    End_token = await iprot.ReadStringAsync(cancellationToken);
                    isset_end_token = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.I32)
                  {
                    Keys_per_split = await iprot.ReadI32Async(cancellationToken);
                    isset_keys_per_split = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_cfName)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_start_token)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_end_token)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_keys_per_split)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("describe_splits_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((CfName != null))
            {
              field.Name = "cfName";
              field.Type = TType.String;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteStringAsync(CfName, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((Start_token != null))
            {
              field.Name = "start_token";
              field.Type = TType.String;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteStringAsync(Start_token, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if((End_token != null))
            {
              field.Name = "end_token";
              field.Type = TType.String;
              field.ID = 3;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteStringAsync(End_token, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "keys_per_split";
            field.Type = TType.I32;
            field.ID = 4;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async(Keys_per_split, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is describe_splitsArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(CfName, other.CfName)
            && System.Object.Equals(Start_token, other.Start_token)
            && System.Object.Equals(End_token, other.End_token)
            && System.Object.Equals(Keys_per_split, other.Keys_per_split);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((CfName != null))
            {
              hashcode = (hashcode * 397) + CfName.GetHashCode();
            }
            if((Start_token != null))
            {
              hashcode = (hashcode * 397) + Start_token.GetHashCode();
            }
            if((End_token != null))
            {
              hashcode = (hashcode * 397) + End_token.GetHashCode();
            }
            hashcode = (hashcode * 397) + Keys_per_split.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("describe_splits_args(");
          if((CfName != null))
          {
            sb.Append(", CfName: ");
            CfName.ToString(sb);
          }
          if((Start_token != null))
          {
            sb.Append(", Start_token: ");
            Start_token.ToString(sb);
          }
          if((End_token != null))
          {
            sb.Append(", End_token: ");
            End_token.ToString(sb);
          }
          sb.Append(", Keys_per_split: ");
          Keys_per_split.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class describe_splitsResult : TBase
      {
        private List<string> _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;

        [DataMember(Order = 0)]
        public List<string> Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        #endregion XmlSerializer support

        public describe_splitsResult()
        {
        }

        public describe_splitsResult DeepCopy()
        {
          var tmp308 = new describe_splitsResult();
          if((Success != null) && __isset.success)
          {
            tmp308.Success = this.Success.DeepCopy();
          }
          tmp308.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp308.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp308.__isset.ire = this.__isset.ire;
          return tmp308;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.List)
                  {
                    {
                      TList _list309 = await iprot.ReadListBeginAsync(cancellationToken);
                      Success = new List<string>(_list309.Count);
                      for(int _i310 = 0; _i310 < _list309.Count; ++_i310)
                      {
                        string _elem311;
                        _elem311 = await iprot.ReadStringAsync(cancellationToken);
                        Success.Add(_elem311);
                      }
                      await iprot.ReadListEndAsync(cancellationToken);
                    }
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.List;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                {
                  await oprot.WriteListBeginAsync(new TList(TType.String, Success.Count), cancellationToken);
                  foreach (string _iter312 in Success)
                  {
                    await oprot.WriteStringAsync(_iter312, cancellationToken);
                  }
                  await oprot.WriteListEndAsync(cancellationToken);
                }
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

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

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

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


      [DataContract(Namespace="")]
      public partial class system_add_column_familyArgs : TBase
      {

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.CfDef Cf_def { get; set; }

        public system_add_column_familyArgs()
        {
        }

        public system_add_column_familyArgs(global::Apache.Cassandra.Test.CfDef cf_def) : this()
        {
          this.Cf_def = cf_def;
        }

        public system_add_column_familyArgs DeepCopy()
        {
          var tmp314 = new system_add_column_familyArgs();
          if((Cf_def != null))
          {
            tmp314.Cf_def = (global::Apache.Cassandra.Test.CfDef)this.Cf_def.DeepCopy();
          }
          return tmp314;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          try
          {
            bool isset_cf_def = false;
            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)
                  {
                    Cf_def = new global::Apache.Cassandra.Test.CfDef();
                    await Cf_def.ReadAsync(iprot, cancellationToken);
                    isset_cf_def = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_cf_def)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

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

        public override bool Equals(object that)
        {
          if (!(that is system_add_column_familyArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Cf_def, other.Cf_def);
        }

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

        public override string ToString()
        {
          var sb = new StringBuilder("system_add_column_family_args(");
          if((Cf_def != null))
          {
            sb.Append(", Cf_def: ");
            Cf_def.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class system_add_column_familyResult : TBase
      {
        private string _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.SchemaDisagreementException _sde;

        [DataMember(Order = 0)]
        public string Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SchemaDisagreementException Sde
        {
          get
          {
            return _sde;
          }
          set
          {
            __isset.sde = true;
            this._sde = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool sde;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeSde()
        {
          return __isset.sde;
        }

        #endregion XmlSerializer support

        public system_add_column_familyResult()
        {
        }

        public system_add_column_familyResult DeepCopy()
        {
          var tmp316 = new system_add_column_familyResult();
          if((Success != null) && __isset.success)
          {
            tmp316.Success = this.Success;
          }
          tmp316.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp316.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp316.__isset.ire = this.__isset.ire;
          if((Sde != null) && __isset.sde)
          {
            tmp316.Sde = (global::Apache.Cassandra.Test.SchemaDisagreementException)this.Sde.DeepCopy();
          }
          tmp316.__isset.sde = this.__isset.sde;
          return tmp316;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.String)
                  {
                    Success = await iprot.ReadStringAsync(cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Sde = new global::Apache.Cassandra.Test.SchemaDisagreementException();
                    await Sde.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.String;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await oprot.WriteStringAsync(Success, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.sde)
            {
              if (Sde != null)
              {
                field.Name = "Sde";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Sde.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

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

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

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


      [DataContract(Namespace="")]
      public partial class system_drop_column_familyArgs : TBase
      {

        [DataMember(Order = 0)]
        public string Column_family { get; set; }

        public system_drop_column_familyArgs()
        {
        }

        public system_drop_column_familyArgs(string column_family) : this()
        {
          this.Column_family = column_family;
        }

        public system_drop_column_familyArgs DeepCopy()
        {
          var tmp318 = new system_drop_column_familyArgs();
          if((Column_family != null))
          {
            tmp318.Column_family = this.Column_family;
          }
          return tmp318;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Column_family = await iprot.ReadStringAsync(cancellationToken);
                    isset_column_family = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_column_family)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

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

        public override bool Equals(object that)
        {
          if (!(that is system_drop_column_familyArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Column_family, other.Column_family);
        }

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

        public override string ToString()
        {
          var sb = new StringBuilder("system_drop_column_family_args(");
          if((Column_family != null))
          {
            sb.Append(", Column_family: ");
            Column_family.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class system_drop_column_familyResult : TBase
      {
        private string _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.SchemaDisagreementException _sde;

        [DataMember(Order = 0)]
        public string Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SchemaDisagreementException Sde
        {
          get
          {
            return _sde;
          }
          set
          {
            __isset.sde = true;
            this._sde = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool sde;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeSde()
        {
          return __isset.sde;
        }

        #endregion XmlSerializer support

        public system_drop_column_familyResult()
        {
        }

        public system_drop_column_familyResult DeepCopy()
        {
          var tmp320 = new system_drop_column_familyResult();
          if((Success != null) && __isset.success)
          {
            tmp320.Success = this.Success;
          }
          tmp320.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp320.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp320.__isset.ire = this.__isset.ire;
          if((Sde != null) && __isset.sde)
          {
            tmp320.Sde = (global::Apache.Cassandra.Test.SchemaDisagreementException)this.Sde.DeepCopy();
          }
          tmp320.__isset.sde = this.__isset.sde;
          return tmp320;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.String)
                  {
                    Success = await iprot.ReadStringAsync(cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Sde = new global::Apache.Cassandra.Test.SchemaDisagreementException();
                    await Sde.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.String;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await oprot.WriteStringAsync(Success, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.sde)
            {
              if (Sde != null)
              {
                field.Name = "Sde";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Sde.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

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

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

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


      [DataContract(Namespace="")]
      public partial class system_add_keyspaceArgs : TBase
      {

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.KsDef Ks_def { get; set; }

        public system_add_keyspaceArgs()
        {
        }

        public system_add_keyspaceArgs(global::Apache.Cassandra.Test.KsDef ks_def) : this()
        {
          this.Ks_def = ks_def;
        }

        public system_add_keyspaceArgs DeepCopy()
        {
          var tmp322 = new system_add_keyspaceArgs();
          if((Ks_def != null))
          {
            tmp322.Ks_def = (global::Apache.Cassandra.Test.KsDef)this.Ks_def.DeepCopy();
          }
          return tmp322;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          try
          {
            bool isset_ks_def = false;
            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)
                  {
                    Ks_def = new global::Apache.Cassandra.Test.KsDef();
                    await Ks_def.ReadAsync(iprot, cancellationToken);
                    isset_ks_def = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_ks_def)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

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

        public override bool Equals(object that)
        {
          if (!(that is system_add_keyspaceArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Ks_def, other.Ks_def);
        }

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

        public override string ToString()
        {
          var sb = new StringBuilder("system_add_keyspace_args(");
          if((Ks_def != null))
          {
            sb.Append(", Ks_def: ");
            Ks_def.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class system_add_keyspaceResult : TBase
      {
        private string _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.SchemaDisagreementException _sde;

        [DataMember(Order = 0)]
        public string Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SchemaDisagreementException Sde
        {
          get
          {
            return _sde;
          }
          set
          {
            __isset.sde = true;
            this._sde = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool sde;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeSde()
        {
          return __isset.sde;
        }

        #endregion XmlSerializer support

        public system_add_keyspaceResult()
        {
        }

        public system_add_keyspaceResult DeepCopy()
        {
          var tmp324 = new system_add_keyspaceResult();
          if((Success != null) && __isset.success)
          {
            tmp324.Success = this.Success;
          }
          tmp324.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp324.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp324.__isset.ire = this.__isset.ire;
          if((Sde != null) && __isset.sde)
          {
            tmp324.Sde = (global::Apache.Cassandra.Test.SchemaDisagreementException)this.Sde.DeepCopy();
          }
          tmp324.__isset.sde = this.__isset.sde;
          return tmp324;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.String)
                  {
                    Success = await iprot.ReadStringAsync(cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Sde = new global::Apache.Cassandra.Test.SchemaDisagreementException();
                    await Sde.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.String;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await oprot.WriteStringAsync(Success, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.sde)
            {
              if (Sde != null)
              {
                field.Name = "Sde";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Sde.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

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

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

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


      [DataContract(Namespace="")]
      public partial class system_drop_keyspaceArgs : TBase
      {

        [DataMember(Order = 0)]
        public string Keyspace { get; set; }

        public system_drop_keyspaceArgs()
        {
        }

        public system_drop_keyspaceArgs(string keyspace) : this()
        {
          this.Keyspace = keyspace;
        }

        public system_drop_keyspaceArgs DeepCopy()
        {
          var tmp326 = new system_drop_keyspaceArgs();
          if((Keyspace != null))
          {
            tmp326.Keyspace = this.Keyspace;
          }
          return tmp326;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Keyspace = await iprot.ReadStringAsync(cancellationToken);
                    isset_keyspace = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_keyspace)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

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

        public override bool Equals(object that)
        {
          if (!(that is system_drop_keyspaceArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Keyspace, other.Keyspace);
        }

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

        public override string ToString()
        {
          var sb = new StringBuilder("system_drop_keyspace_args(");
          if((Keyspace != null))
          {
            sb.Append(", Keyspace: ");
            Keyspace.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class system_drop_keyspaceResult : TBase
      {
        private string _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.SchemaDisagreementException _sde;

        [DataMember(Order = 0)]
        public string Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SchemaDisagreementException Sde
        {
          get
          {
            return _sde;
          }
          set
          {
            __isset.sde = true;
            this._sde = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool sde;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeSde()
        {
          return __isset.sde;
        }

        #endregion XmlSerializer support

        public system_drop_keyspaceResult()
        {
        }

        public system_drop_keyspaceResult DeepCopy()
        {
          var tmp328 = new system_drop_keyspaceResult();
          if((Success != null) && __isset.success)
          {
            tmp328.Success = this.Success;
          }
          tmp328.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp328.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp328.__isset.ire = this.__isset.ire;
          if((Sde != null) && __isset.sde)
          {
            tmp328.Sde = (global::Apache.Cassandra.Test.SchemaDisagreementException)this.Sde.DeepCopy();
          }
          tmp328.__isset.sde = this.__isset.sde;
          return tmp328;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.String)
                  {
                    Success = await iprot.ReadStringAsync(cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Sde = new global::Apache.Cassandra.Test.SchemaDisagreementException();
                    await Sde.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.String;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await oprot.WriteStringAsync(Success, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.sde)
            {
              if (Sde != null)
              {
                field.Name = "Sde";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Sde.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

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

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

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


      [DataContract(Namespace="")]
      public partial class system_update_keyspaceArgs : TBase
      {

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.KsDef Ks_def { get; set; }

        public system_update_keyspaceArgs()
        {
        }

        public system_update_keyspaceArgs(global::Apache.Cassandra.Test.KsDef ks_def) : this()
        {
          this.Ks_def = ks_def;
        }

        public system_update_keyspaceArgs DeepCopy()
        {
          var tmp330 = new system_update_keyspaceArgs();
          if((Ks_def != null))
          {
            tmp330.Ks_def = (global::Apache.Cassandra.Test.KsDef)this.Ks_def.DeepCopy();
          }
          return tmp330;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          try
          {
            bool isset_ks_def = false;
            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)
                  {
                    Ks_def = new global::Apache.Cassandra.Test.KsDef();
                    await Ks_def.ReadAsync(iprot, cancellationToken);
                    isset_ks_def = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_ks_def)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

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

        public override bool Equals(object that)
        {
          if (!(that is system_update_keyspaceArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Ks_def, other.Ks_def);
        }

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

        public override string ToString()
        {
          var sb = new StringBuilder("system_update_keyspace_args(");
          if((Ks_def != null))
          {
            sb.Append(", Ks_def: ");
            Ks_def.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class system_update_keyspaceResult : TBase
      {
        private string _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.SchemaDisagreementException _sde;

        [DataMember(Order = 0)]
        public string Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SchemaDisagreementException Sde
        {
          get
          {
            return _sde;
          }
          set
          {
            __isset.sde = true;
            this._sde = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool sde;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeSde()
        {
          return __isset.sde;
        }

        #endregion XmlSerializer support

        public system_update_keyspaceResult()
        {
        }

        public system_update_keyspaceResult DeepCopy()
        {
          var tmp332 = new system_update_keyspaceResult();
          if((Success != null) && __isset.success)
          {
            tmp332.Success = this.Success;
          }
          tmp332.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp332.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp332.__isset.ire = this.__isset.ire;
          if((Sde != null) && __isset.sde)
          {
            tmp332.Sde = (global::Apache.Cassandra.Test.SchemaDisagreementException)this.Sde.DeepCopy();
          }
          tmp332.__isset.sde = this.__isset.sde;
          return tmp332;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.String)
                  {
                    Success = await iprot.ReadStringAsync(cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Sde = new global::Apache.Cassandra.Test.SchemaDisagreementException();
                    await Sde.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.String;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await oprot.WriteStringAsync(Success, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.sde)
            {
              if (Sde != null)
              {
                field.Name = "Sde";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Sde.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

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

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

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


      [DataContract(Namespace="")]
      public partial class system_update_column_familyArgs : TBase
      {

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.CfDef Cf_def { get; set; }

        public system_update_column_familyArgs()
        {
        }

        public system_update_column_familyArgs(global::Apache.Cassandra.Test.CfDef cf_def) : this()
        {
          this.Cf_def = cf_def;
        }

        public system_update_column_familyArgs DeepCopy()
        {
          var tmp334 = new system_update_column_familyArgs();
          if((Cf_def != null))
          {
            tmp334.Cf_def = (global::Apache.Cassandra.Test.CfDef)this.Cf_def.DeepCopy();
          }
          return tmp334;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          try
          {
            bool isset_cf_def = false;
            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)
                  {
                    Cf_def = new global::Apache.Cassandra.Test.CfDef();
                    await Cf_def.ReadAsync(iprot, cancellationToken);
                    isset_cf_def = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_cf_def)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

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

        public override bool Equals(object that)
        {
          if (!(that is system_update_column_familyArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(Cf_def, other.Cf_def);
        }

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

        public override string ToString()
        {
          var sb = new StringBuilder("system_update_column_family_args(");
          if((Cf_def != null))
          {
            sb.Append(", Cf_def: ");
            Cf_def.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class system_update_column_familyResult : TBase
      {
        private string _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.SchemaDisagreementException _sde;

        [DataMember(Order = 0)]
        public string Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SchemaDisagreementException Sde
        {
          get
          {
            return _sde;
          }
          set
          {
            __isset.sde = true;
            this._sde = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool sde;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeSde()
        {
          return __isset.sde;
        }

        #endregion XmlSerializer support

        public system_update_column_familyResult()
        {
        }

        public system_update_column_familyResult DeepCopy()
        {
          var tmp336 = new system_update_column_familyResult();
          if((Success != null) && __isset.success)
          {
            tmp336.Success = this.Success;
          }
          tmp336.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp336.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp336.__isset.ire = this.__isset.ire;
          if((Sde != null) && __isset.sde)
          {
            tmp336.Sde = (global::Apache.Cassandra.Test.SchemaDisagreementException)this.Sde.DeepCopy();
          }
          tmp336.__isset.sde = this.__isset.sde;
          return tmp336;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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.String)
                  {
                    Success = await iprot.ReadStringAsync(cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Sde = new global::Apache.Cassandra.Test.SchemaDisagreementException();
                    await Sde.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

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

            if(this.__isset.success)
            {
              if (Success != null)
              {
                field.Name = "Success";
                field.Type = TType.String;
                field.ID = 0;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await oprot.WriteStringAsync(Success, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.sde)
            {
              if (Sde != null)
              {
                field.Name = "Sde";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Sde.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

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

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

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


      [DataContract(Namespace="")]
      public partial class execute_cql_queryArgs : TBase
      {

        [DataMember(Order = 0)]
        public byte[] Query { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.Compression"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.Compression Compression { get; set; }

        public execute_cql_queryArgs()
        {
        }

        public execute_cql_queryArgs(byte[] query, global::Apache.Cassandra.Test.Compression compression) : this()
        {
          this.Query = query;
          this.Compression = compression;
        }

        public execute_cql_queryArgs DeepCopy()
        {
          var tmp338 = new execute_cql_queryArgs();
          if((Query != null))
          {
            tmp338.Query = this.Query.ToArray();
          }
          tmp338.Compression = this.Compression;
          return tmp338;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Query = await iprot.ReadBinaryAsync(cancellationToken);
                    isset_query = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.I32)
                  {
                    Compression = (global::Apache.Cassandra.Test.Compression)await iprot.ReadI32Async(cancellationToken);
                    isset_compression = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_query)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_compression)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("execute_cql_query_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Query != null))
            {
              field.Name = "query";
              field.Type = TType.String;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteBinaryAsync(Query, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "compression";
            field.Type = TType.I32;
            field.ID = 2;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Compression, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is execute_cql_queryArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return TCollections.Equals(Query, other.Query)
            && System.Object.Equals(Compression, other.Compression);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Query != null))
            {
              hashcode = (hashcode * 397) + Query.GetHashCode();
            }
            hashcode = (hashcode * 397) + Compression.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("execute_cql_query_args(");
          if((Query != null))
          {
            sb.Append(", Query: ");
            Query.ToString(sb);
          }
          sb.Append(", Compression: ");
          Compression.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class execute_cql_queryResult : TBase
      {
        private global::Apache.Cassandra.Test.CqlResult _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;
        private global::Apache.Cassandra.Test.SchemaDisagreementException _sde;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.CqlResult Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SchemaDisagreementException Sde
        {
          get
          {
            return _sde;
          }
          set
          {
            __isset.sde = true;
            this._sde = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
          [DataMember]
          public bool sde;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        public bool ShouldSerializeSde()
        {
          return __isset.sde;
        }

        #endregion XmlSerializer support

        public execute_cql_queryResult()
        {
        }

        public execute_cql_queryResult DeepCopy()
        {
          var tmp340 = new execute_cql_queryResult();
          if((Success != null) && __isset.success)
          {
            tmp340.Success = (global::Apache.Cassandra.Test.CqlResult)this.Success.DeepCopy();
          }
          tmp340.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp340.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp340.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp340.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp340.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp340.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp340.__isset.te = this.__isset.te;
          if((Sde != null) && __isset.sde)
          {
            tmp340.Sde = (global::Apache.Cassandra.Test.SchemaDisagreementException)this.Sde.DeepCopy();
          }
          tmp340.__isset.sde = this.__isset.sde;
          return tmp340;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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 global::Apache.Cassandra.Test.CqlResult();
                    await Success.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.Struct)
                  {
                    Sde = new global::Apache.Cassandra.Test.SchemaDisagreementException();
                    await Sde.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("execute_cql_query_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);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.sde)
            {
              if (Sde != null)
              {
                field.Name = "Sde";
                field.Type = TType.Struct;
                field.ID = 4;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Sde.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is execute_cql_queryResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))))
            && ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))))
            && ((__isset.sde == other.__isset.sde) && ((!__isset.sde) || (System.Object.Equals(Sde, other.Sde))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Success != null) && __isset.success)
            {
              hashcode = (hashcode * 397) + Success.GetHashCode();
            }
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
            if((Sde != null) && __isset.sde)
            {
              hashcode = (hashcode * 397) + Sde.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("execute_cql_query_result(");
          int tmp341 = 0;
          if((Success != null) && __isset.success)
          {
            if(0 < tmp341++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp341++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp341++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp341++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          if((Sde != null) && __isset.sde)
          {
            if(0 < tmp341++) { sb.Append(", "); }
            sb.Append("Sde: ");
            Sde.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class prepare_cql_queryArgs : TBase
      {

        [DataMember(Order = 0)]
        public byte[] Query { get; set; }

        /// <summary>
        /// 
        /// <seealso cref="global::Apache.Cassandra.Test.Compression"/>
        /// </summary>
        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.Compression Compression { get; set; }

        public prepare_cql_queryArgs()
        {
        }

        public prepare_cql_queryArgs(byte[] query, global::Apache.Cassandra.Test.Compression compression) : this()
        {
          this.Query = query;
          this.Compression = compression;
        }

        public prepare_cql_queryArgs DeepCopy()
        {
          var tmp342 = new prepare_cql_queryArgs();
          if((Query != null))
          {
            tmp342.Query = this.Query.ToArray();
          }
          tmp342.Compression = this.Compression;
          return tmp342;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.String)
                  {
                    Query = await iprot.ReadBinaryAsync(cancellationToken);
                    isset_query = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.I32)
                  {
                    Compression = (global::Apache.Cassandra.Test.Compression)await iprot.ReadI32Async(cancellationToken);
                    isset_compression = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_query)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_compression)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("prepare_cql_query_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            if((Query != null))
            {
              field.Name = "query";
              field.Type = TType.String;
              field.ID = 1;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              await oprot.WriteBinaryAsync(Query, cancellationToken);
              await oprot.WriteFieldEndAsync(cancellationToken);
            }
            field.Name = "compression";
            field.Type = TType.I32;
            field.ID = 2;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async((int)Compression, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is prepare_cql_queryArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return TCollections.Equals(Query, other.Query)
            && System.Object.Equals(Compression, other.Compression);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Query != null))
            {
              hashcode = (hashcode * 397) + Query.GetHashCode();
            }
            hashcode = (hashcode * 397) + Compression.GetHashCode();
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("prepare_cql_query_args(");
          if((Query != null))
          {
            sb.Append(", Query: ");
            Query.ToString(sb);
          }
          sb.Append(", Compression: ");
          Compression.ToString(sb);
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class prepare_cql_queryResult : TBase
      {
        private global::Apache.Cassandra.Test.CqlPreparedResult _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.CqlPreparedResult Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        #endregion XmlSerializer support

        public prepare_cql_queryResult()
        {
        }

        public prepare_cql_queryResult DeepCopy()
        {
          var tmp344 = new prepare_cql_queryResult();
          if((Success != null) && __isset.success)
          {
            tmp344.Success = (global::Apache.Cassandra.Test.CqlPreparedResult)this.Success.DeepCopy();
          }
          tmp344.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp344.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp344.__isset.ire = this.__isset.ire;
          return tmp344;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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 global::Apache.Cassandra.Test.CqlPreparedResult();
                    await Success.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("prepare_cql_query_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);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

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

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

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


      [DataContract(Namespace="")]
      public partial class execute_prepared_cql_queryArgs : TBase
      {

        [DataMember(Order = 0)]
        public int ItemId { get; set; }

        [DataMember(Order = 0)]
        public List<string> Values { get; set; }

        public execute_prepared_cql_queryArgs()
        {
        }

        public execute_prepared_cql_queryArgs(int itemId, List<string> values) : this()
        {
          this.ItemId = itemId;
          this.Values = values;
        }

        public execute_prepared_cql_queryArgs DeepCopy()
        {
          var tmp346 = new execute_prepared_cql_queryArgs();
          tmp346.ItemId = this.ItemId;
          if((Values != null))
          {
            tmp346.Values = this.Values.DeepCopy();
          }
          return tmp346;
        }

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

              switch (field.ID)
              {
                case 1:
                  if (field.Type == TType.I32)
                  {
                    ItemId = await iprot.ReadI32Async(cancellationToken);
                    isset_itemId = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.List)
                  {
                    {
                      TList _list347 = await iprot.ReadListBeginAsync(cancellationToken);
                      Values = new List<string>(_list347.Count);
                      for(int _i348 = 0; _i348 < _list347.Count; ++_i348)
                      {
                        string _elem349;
                        _elem349 = await iprot.ReadStringAsync(cancellationToken);
                        Values.Add(_elem349);
                      }
                      await iprot.ReadListEndAsync(cancellationToken);
                    }
                    isset_values = true;
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
            if (!isset_itemId)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_values)
            {
              throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
          }
          finally
          {
            iprot.DecrementRecursionDepth();
          }
        }

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("execute_prepared_cql_query_args");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);
            var field = new TField();
            field.Name = "itemId";
            field.Type = TType.I32;
            field.ID = 1;
            await oprot.WriteFieldBeginAsync(field, cancellationToken);
            await oprot.WriteI32Async(ItemId, cancellationToken);
            await oprot.WriteFieldEndAsync(cancellationToken);
            if((Values != null))
            {
              field.Name = "values";
              field.Type = TType.List;
              field.ID = 2;
              await oprot.WriteFieldBeginAsync(field, cancellationToken);
              {
                await oprot.WriteListBeginAsync(new TList(TType.String, Values.Count), cancellationToken);
                foreach (string _iter350 in Values)
                {
                  await oprot.WriteStringAsync(_iter350, 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 execute_prepared_cql_queryArgs other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return System.Object.Equals(ItemId, other.ItemId)
            && TCollections.Equals(Values, other.Values);
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            hashcode = (hashcode * 397) + ItemId.GetHashCode();
            if((Values != null))
            {
              hashcode = (hashcode * 397) + TCollections.GetHashCode(Values);
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("execute_prepared_cql_query_args(");
          sb.Append(", ItemId: ");
          ItemId.ToString(sb);
          if((Values != null))
          {
            sb.Append(", Values: ");
            Values.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }


      [DataContract(Namespace="")]
      public partial class execute_prepared_cql_queryResult : TBase
      {
        private global::Apache.Cassandra.Test.CqlResult _success;
        private global::Apache.Cassandra.Test.InvalidRequestException _ire;
        private global::Apache.Cassandra.Test.UnavailableException _ue;
        private global::Apache.Cassandra.Test.TimedOutException _te;
        private global::Apache.Cassandra.Test.SchemaDisagreementException _sde;

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.CqlResult Success
        {
          get
          {
            return _success;
          }
          set
          {
            __isset.success = true;
            this._success = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.InvalidRequestException Ire
        {
          get
          {
            return _ire;
          }
          set
          {
            __isset.ire = true;
            this._ire = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.UnavailableException Ue
        {
          get
          {
            return _ue;
          }
          set
          {
            __isset.ue = true;
            this._ue = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.TimedOutException Te
        {
          get
          {
            return _te;
          }
          set
          {
            __isset.te = true;
            this._te = value;
          }
        }

        [DataMember(Order = 0)]
        public global::Apache.Cassandra.Test.SchemaDisagreementException Sde
        {
          get
          {
            return _sde;
          }
          set
          {
            __isset.sde = true;
            this._sde = value;
          }
        }


        [DataMember(Order = 1)]
        public Isset __isset;
        [DataContract]
        public struct Isset
        {
          [DataMember]
          public bool success;
          [DataMember]
          public bool ire;
          [DataMember]
          public bool ue;
          [DataMember]
          public bool te;
          [DataMember]
          public bool sde;
        }

        #region XmlSerializer support

        public bool ShouldSerializeSuccess()
        {
          return __isset.success;
        }

        public bool ShouldSerializeIre()
        {
          return __isset.ire;
        }

        public bool ShouldSerializeUe()
        {
          return __isset.ue;
        }

        public bool ShouldSerializeTe()
        {
          return __isset.te;
        }

        public bool ShouldSerializeSde()
        {
          return __isset.sde;
        }

        #endregion XmlSerializer support

        public execute_prepared_cql_queryResult()
        {
        }

        public execute_prepared_cql_queryResult DeepCopy()
        {
          var tmp352 = new execute_prepared_cql_queryResult();
          if((Success != null) && __isset.success)
          {
            tmp352.Success = (global::Apache.Cassandra.Test.CqlResult)this.Success.DeepCopy();
          }
          tmp352.__isset.success = this.__isset.success;
          if((Ire != null) && __isset.ire)
          {
            tmp352.Ire = (global::Apache.Cassandra.Test.InvalidRequestException)this.Ire.DeepCopy();
          }
          tmp352.__isset.ire = this.__isset.ire;
          if((Ue != null) && __isset.ue)
          {
            tmp352.Ue = (global::Apache.Cassandra.Test.UnavailableException)this.Ue.DeepCopy();
          }
          tmp352.__isset.ue = this.__isset.ue;
          if((Te != null) && __isset.te)
          {
            tmp352.Te = (global::Apache.Cassandra.Test.TimedOutException)this.Te.DeepCopy();
          }
          tmp352.__isset.te = this.__isset.te;
          if((Sde != null) && __isset.sde)
          {
            tmp352.Sde = (global::Apache.Cassandra.Test.SchemaDisagreementException)this.Sde.DeepCopy();
          }
          tmp352.__isset.sde = this.__isset.sde;
          return tmp352;
        }

        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
          iprot.IncrementRecursionDepth();
          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 global::Apache.Cassandra.Test.CqlResult();
                    await Success.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 1:
                  if (field.Type == TType.Struct)
                  {
                    Ire = new global::Apache.Cassandra.Test.InvalidRequestException();
                    await Ire.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 2:
                  if (field.Type == TType.Struct)
                  {
                    Ue = new global::Apache.Cassandra.Test.UnavailableException();
                    await Ue.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 3:
                  if (field.Type == TType.Struct)
                  {
                    Te = new global::Apache.Cassandra.Test.TimedOutException();
                    await Te.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                case 4:
                  if (field.Type == TType.Struct)
                  {
                    Sde = new global::Apache.Cassandra.Test.SchemaDisagreementException();
                    await Sde.ReadAsync(iprot, cancellationToken);
                  }
                  else
                  {
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  }
                  break;
                default: 
                  await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                  break;
              }

              await iprot.ReadFieldEndAsync(cancellationToken);
            }

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

        public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
          oprot.IncrementRecursionDepth();
          try
          {
            var struc = new TStruct("execute_prepared_cql_query_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);
              }
            }
            else if(this.__isset.ire)
            {
              if (Ire != null)
              {
                field.Name = "Ire";
                field.Type = TType.Struct;
                field.ID = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ire.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.ue)
            {
              if (Ue != null)
              {
                field.Name = "Ue";
                field.Type = TType.Struct;
                field.ID = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Ue.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.te)
            {
              if (Te != null)
              {
                field.Name = "Te";
                field.Type = TType.Struct;
                field.ID = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Te.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            else if(this.__isset.sde)
            {
              if (Sde != null)
              {
                field.Name = "Sde";
                field.Type = TType.Struct;
                field.ID = 4;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);
                await Sde.WriteAsync(oprot, cancellationToken);
                await oprot.WriteFieldEndAsync(cancellationToken);
              }
            }
            await oprot.WriteFieldStopAsync(cancellationToken);
            await oprot.WriteStructEndAsync(cancellationToken);
          }
          finally
          {
            oprot.DecrementRecursionDepth();
          }
        }

        public override bool Equals(object that)
        {
          if (!(that is execute_prepared_cql_queryResult other)) return false;
          if (ReferenceEquals(this, other)) return true;
          return ((__isset.success == other.__isset.success) && ((!__isset.success) || (System.Object.Equals(Success, other.Success))))
            && ((__isset.ire == other.__isset.ire) && ((!__isset.ire) || (System.Object.Equals(Ire, other.Ire))))
            && ((__isset.ue == other.__isset.ue) && ((!__isset.ue) || (System.Object.Equals(Ue, other.Ue))))
            && ((__isset.te == other.__isset.te) && ((!__isset.te) || (System.Object.Equals(Te, other.Te))))
            && ((__isset.sde == other.__isset.sde) && ((!__isset.sde) || (System.Object.Equals(Sde, other.Sde))));
        }

        public override int GetHashCode() {
          int hashcode = 157;
          unchecked {
            if((Success != null) && __isset.success)
            {
              hashcode = (hashcode * 397) + Success.GetHashCode();
            }
            if((Ire != null) && __isset.ire)
            {
              hashcode = (hashcode * 397) + Ire.GetHashCode();
            }
            if((Ue != null) && __isset.ue)
            {
              hashcode = (hashcode * 397) + Ue.GetHashCode();
            }
            if((Te != null) && __isset.te)
            {
              hashcode = (hashcode * 397) + Te.GetHashCode();
            }
            if((Sde != null) && __isset.sde)
            {
              hashcode = (hashcode * 397) + Sde.GetHashCode();
            }
          }
          return hashcode;
        }

        public override string ToString()
        {
          var sb = new StringBuilder("execute_prepared_cql_query_result(");
          int tmp353 = 0;
          if((Success != null) && __isset.success)
          {
            if(0 < tmp353++) { sb.Append(", "); }
            sb.Append("Success: ");
            Success.ToString(sb);
          }
          if((Ire != null) && __isset.ire)
          {
            if(0 < tmp353++) { sb.Append(", "); }
            sb.Append("Ire: ");
            Ire.ToString(sb);
          }
          if((Ue != null) && __isset.ue)
          {
            if(0 < tmp353++) { sb.Append(", "); }
            sb.Append("Ue: ");
            Ue.ToString(sb);
          }
          if((Te != null) && __isset.te)
          {
            if(0 < tmp353++) { sb.Append(", "); }
            sb.Append("Te: ");
            Te.ToString(sb);
          }
          if((Sde != null) && __isset.sde)
          {
            if(0 < tmp353++) { sb.Append(", "); }
            sb.Append("Sde: ");
            Sde.ToString(sb);
          }
          sb.Append(')');
          return sb.ToString();
        }
      }

    }

  }
}
