KineticaFunctions.cs

Go to the documentation of this file.

/*
 *  This file was autogenerated by the Kinetica schema processor.
 *
 *  DO NOT EDIT DIRECTLY.
 */

using Avro;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace kinetica;

public partial class Kinetica
{
    // Kinetica Version
    public const string API_VERSION = "7.2.3.1";

    public AdminAddHostResponse adminAddHost( AdminAddHostRequest request_ )
    {
        AdminAddHostResponse actualResponse_ = SubmitRequest<AdminAddHostResponse>("/admin/add/host", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminAddHostResponse> AdminAddHostAsync( AdminAddHostRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        AdminAddHostResponse actualResponse_ = await SubmitRequestAsync<AdminAddHostResponse>("/admin/add/host", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminAddHostResponse adminAddHost( string host_address,
                                              IDictionary<string, string> options = null )
    {
        return adminAddHost( new AdminAddHostRequest( host_address, options ) );
    }

    public async System.Threading.Tasks.Task<AdminAddHostResponse> AdminAddHostAsync( string host_address,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminAddHostAsync( new AdminAddHostRequest( host_address, options ), cancellationToken );
    }

    public AdminAddRanksResponse adminAddRanks( AdminAddRanksRequest request_ )
    {
        AdminAddRanksResponse actualResponse_ = SubmitRequest<AdminAddRanksResponse>("/admin/add/ranks", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminAddRanksResponse> AdminAddRanksAsync( AdminAddRanksRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        AdminAddRanksResponse actualResponse_ = await SubmitRequestAsync<AdminAddRanksResponse>("/admin/add/ranks", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminAddRanksResponse adminAddRanks( IList<string> hosts,
                                                IList<IDictionary<string, string>> config_params,
                                                IDictionary<string, string> options = null )
    {
        return adminAddRanks( new AdminAddRanksRequest( hosts, config_params, options ) );
    }

    public async System.Threading.Tasks.Task<AdminAddRanksResponse> AdminAddRanksAsync( IList<string> hosts,
                                                                                        IList<IDictionary<string, string>> config_params,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminAddRanksAsync( new AdminAddRanksRequest( hosts, config_params,
                                                                   options ), cancellationToken );
    }

    public AdminAlterHostResponse adminAlterHost( AdminAlterHostRequest request_ )
    {
        AdminAlterHostResponse actualResponse_ = SubmitRequest<AdminAlterHostResponse>("/admin/alter/host", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminAlterHostResponse> AdminAlterHostAsync( AdminAlterHostRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        AdminAlterHostResponse actualResponse_ = await SubmitRequestAsync<AdminAlterHostResponse>("/admin/alter/host", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminAlterHostResponse adminAlterHost( string host,
                                                  IDictionary<string, string> options = null )
    {
        return adminAlterHost( new AdminAlterHostRequest( host, options ) );
    }

    public async System.Threading.Tasks.Task<AdminAlterHostResponse> AdminAlterHostAsync( string host,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminAlterHostAsync( new AdminAlterHostRequest( host, options ), cancellationToken );
    }

    public AdminAlterJobsResponse adminAlterJobs( AdminAlterJobsRequest request_ )
    {
        AdminAlterJobsResponse actualResponse_ = SubmitRequest<AdminAlterJobsResponse>("/admin/alter/jobs", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminAlterJobsResponse> AdminAlterJobsAsync( AdminAlterJobsRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        AdminAlterJobsResponse actualResponse_ = await SubmitRequestAsync<AdminAlterJobsResponse>("/admin/alter/jobs", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminAlterJobsResponse adminAlterJobs( IList<long> job_ids,
                                                  string action,
                                                  IDictionary<string, string> options = null )
    {
        return adminAlterJobs( new AdminAlterJobsRequest( job_ids, action, options ) );
    }

    public async System.Threading.Tasks.Task<AdminAlterJobsResponse> AdminAlterJobsAsync( IList<long> job_ids,
                                                                                          string action,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminAlterJobsAsync( new AdminAlterJobsRequest( job_ids, action,
                                                                     options ), cancellationToken );
    }

    public AdminBackupBeginResponse adminBackupBegin( AdminBackupBeginRequest request_ )
    {
        AdminBackupBeginResponse actualResponse_ = SubmitRequest<AdminBackupBeginResponse>("/admin/backup/begin", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminBackupBeginResponse> AdminBackupBeginAsync( AdminBackupBeginRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        AdminBackupBeginResponse actualResponse_ = await SubmitRequestAsync<AdminBackupBeginResponse>("/admin/backup/begin", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminBackupBeginResponse adminBackupBegin( IDictionary<string, string> options = null )
    {
        return adminBackupBegin( new AdminBackupBeginRequest( options ) );
    }

    public async System.Threading.Tasks.Task<AdminBackupBeginResponse> AdminBackupBeginAsync( IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminBackupBeginAsync( new AdminBackupBeginRequest( options ), cancellationToken );
    }

    public AdminBackupEndResponse adminBackupEnd( AdminBackupEndRequest request_ )
    {
        AdminBackupEndResponse actualResponse_ = SubmitRequest<AdminBackupEndResponse>("/admin/backup/end", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminBackupEndResponse> AdminBackupEndAsync( AdminBackupEndRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        AdminBackupEndResponse actualResponse_ = await SubmitRequestAsync<AdminBackupEndResponse>("/admin/backup/end", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminBackupEndResponse adminBackupEnd( IDictionary<string, string> options = null )
    {
        return adminBackupEnd( new AdminBackupEndRequest( options ) );
    }

    public async System.Threading.Tasks.Task<AdminBackupEndResponse> AdminBackupEndAsync( IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminBackupEndAsync( new AdminBackupEndRequest( options ), cancellationToken );
    }

    public AdminHaOfflineResponse adminHaOffline( AdminHaOfflineRequest request_ )
    {
        AdminHaOfflineResponse actualResponse_ = SubmitRequest<AdminHaOfflineResponse>("/admin/ha/offline", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminHaOfflineResponse> AdminHaOfflineAsync( AdminHaOfflineRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        AdminHaOfflineResponse actualResponse_ = await SubmitRequestAsync<AdminHaOfflineResponse>("/admin/ha/offline", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminHaOfflineResponse adminHaOffline( bool offline,
                                                  IDictionary<string, string> options = null )
    {
        return adminHaOffline( new AdminHaOfflineRequest( offline, options ) );
    }

    public async System.Threading.Tasks.Task<AdminHaOfflineResponse> AdminHaOfflineAsync( bool offline,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminHaOfflineAsync( new AdminHaOfflineRequest( offline, options ), cancellationToken );
    }

    public AdminHaRefreshResponse adminHaRefresh( AdminHaRefreshRequest request_ )
    {
        AdminHaRefreshResponse actualResponse_ = SubmitRequest<AdminHaRefreshResponse>("/admin/ha/refresh", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminHaRefreshResponse> AdminHaRefreshAsync( AdminHaRefreshRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        AdminHaRefreshResponse actualResponse_ = await SubmitRequestAsync<AdminHaRefreshResponse>("/admin/ha/refresh", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminHaRefreshResponse adminHaRefresh( IDictionary<string, string> options = null )
    {
        return adminHaRefresh( new AdminHaRefreshRequest( options ) );
    }

    public async System.Threading.Tasks.Task<AdminHaRefreshResponse> AdminHaRefreshAsync( IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminHaRefreshAsync( new AdminHaRefreshRequest( options ), cancellationToken );
    }

    public AdminOfflineResponse adminOffline( AdminOfflineRequest request_ )
    {
        AdminOfflineResponse actualResponse_ = SubmitRequest<AdminOfflineResponse>("/admin/offline", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminOfflineResponse> AdminOfflineAsync( AdminOfflineRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        AdminOfflineResponse actualResponse_ = await SubmitRequestAsync<AdminOfflineResponse>("/admin/offline", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminOfflineResponse adminOffline( bool offline,
                                              IDictionary<string, string> options = null )
    {
        return adminOffline( new AdminOfflineRequest( offline, options ) );
    }

    public async System.Threading.Tasks.Task<AdminOfflineResponse> AdminOfflineAsync( bool offline,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminOfflineAsync( new AdminOfflineRequest( offline, options ), cancellationToken );
    }

    public AdminRebalanceResponse adminRebalance( AdminRebalanceRequest request_ )
    {
        AdminRebalanceResponse actualResponse_ = SubmitRequest<AdminRebalanceResponse>("/admin/rebalance", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminRebalanceResponse> AdminRebalanceAsync( AdminRebalanceRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        AdminRebalanceResponse actualResponse_ = await SubmitRequestAsync<AdminRebalanceResponse>("/admin/rebalance", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminRebalanceResponse adminRebalance( IDictionary<string, string> options = null )
    {
        return adminRebalance( new AdminRebalanceRequest( options ) );
    }

    public async System.Threading.Tasks.Task<AdminRebalanceResponse> AdminRebalanceAsync( IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminRebalanceAsync( new AdminRebalanceRequest( options ), cancellationToken );
    }

    public AdminRemoveHostResponse adminRemoveHost( AdminRemoveHostRequest request_ )
    {
        AdminRemoveHostResponse actualResponse_ = SubmitRequest<AdminRemoveHostResponse>("/admin/remove/host", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminRemoveHostResponse> AdminRemoveHostAsync( AdminRemoveHostRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        AdminRemoveHostResponse actualResponse_ = await SubmitRequestAsync<AdminRemoveHostResponse>("/admin/remove/host", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminRemoveHostResponse adminRemoveHost( string host,
                                                    IDictionary<string, string> options = null )
    {
        return adminRemoveHost( new AdminRemoveHostRequest( host, options ) );
    }

    public async System.Threading.Tasks.Task<AdminRemoveHostResponse> AdminRemoveHostAsync( string host,
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminRemoveHostAsync( new AdminRemoveHostRequest( host, options ), cancellationToken );
    }

    public AdminRemoveRanksResponse adminRemoveRanks( AdminRemoveRanksRequest request_ )
    {
        AdminRemoveRanksResponse actualResponse_ = SubmitRequest<AdminRemoveRanksResponse>("/admin/remove/ranks", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminRemoveRanksResponse> AdminRemoveRanksAsync( AdminRemoveRanksRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        AdminRemoveRanksResponse actualResponse_ = await SubmitRequestAsync<AdminRemoveRanksResponse>("/admin/remove/ranks", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminRemoveRanksResponse adminRemoveRanks( IList<string> ranks,
                                                      IDictionary<string, string> options = null )
    {
        return adminRemoveRanks( new AdminRemoveRanksRequest( ranks, options ) );
    }

    public async System.Threading.Tasks.Task<AdminRemoveRanksResponse> AdminRemoveRanksAsync( IList<string> ranks,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminRemoveRanksAsync( new AdminRemoveRanksRequest( ranks, options ), cancellationToken );
    }

    public AdminRepairTableResponse adminRepairTable( AdminRepairTableRequest request_ )
    {
        AdminRepairTableResponse actualResponse_ = SubmitRequest<AdminRepairTableResponse>("/admin/repair/table", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminRepairTableResponse> AdminRepairTableAsync( AdminRepairTableRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        AdminRepairTableResponse actualResponse_ = await SubmitRequestAsync<AdminRepairTableResponse>("/admin/repair/table", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminRepairTableResponse adminRepairTable( IList<string> table_names,
                                                      IDictionary<string, string> table_types,
                                                      IDictionary<string, string> options = null )
    {
        return adminRepairTable( new AdminRepairTableRequest( table_names, table_types,
                                                              options ) );
    }

    public async System.Threading.Tasks.Task<AdminRepairTableResponse> AdminRepairTableAsync( IList<string> table_names,
                                                                                              IDictionary<string, string> table_types,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminRepairTableAsync( new AdminRepairTableRequest( table_names,
                                                                         table_types,
                                                                         options ), cancellationToken );
    }

    public AdminSendAlertResponse adminSendAlert( AdminSendAlertRequest request_ )
    {
        AdminSendAlertResponse actualResponse_ = SubmitRequest<AdminSendAlertResponse>("/admin/send/alert", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminSendAlertResponse> AdminSendAlertAsync( AdminSendAlertRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        AdminSendAlertResponse actualResponse_ = await SubmitRequestAsync<AdminSendAlertResponse>("/admin/send/alert", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminSendAlertResponse adminSendAlert( string message,
                                                  string label,
                                                  string log_level,
                                                  IDictionary<string, string> options = null )
    {
        return adminSendAlert( new AdminSendAlertRequest( message, label, log_level,
                                                          options ) );
    }

    public async System.Threading.Tasks.Task<AdminSendAlertResponse> AdminSendAlertAsync( string message,
                                                                                          string label,
                                                                                          string log_level,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminSendAlertAsync( new AdminSendAlertRequest( message, label,
                                                                     log_level, options ), cancellationToken );
    }

    public AdminShowAlertsResponse adminShowAlerts( AdminShowAlertsRequest request_ )
    {
        AdminShowAlertsResponse actualResponse_ = SubmitRequest<AdminShowAlertsResponse>("/admin/show/alerts", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminShowAlertsResponse> AdminShowAlertsAsync( AdminShowAlertsRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        AdminShowAlertsResponse actualResponse_ = await SubmitRequestAsync<AdminShowAlertsResponse>("/admin/show/alerts", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminShowAlertsResponse adminShowAlerts( int num_alerts,
                                                    IDictionary<string, string> options = null )
    {
        return adminShowAlerts( new AdminShowAlertsRequest( num_alerts, options ) );
    }

    public async System.Threading.Tasks.Task<AdminShowAlertsResponse> AdminShowAlertsAsync( int num_alerts,
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminShowAlertsAsync( new AdminShowAlertsRequest( num_alerts, options ), cancellationToken );
    }

    public AdminShowClusterOperationsResponse adminShowClusterOperations( AdminShowClusterOperationsRequest request_ )
    {
        AdminShowClusterOperationsResponse actualResponse_ = SubmitRequest<AdminShowClusterOperationsResponse>("/admin/show/cluster/operations", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminShowClusterOperationsResponse> AdminShowClusterOperationsAsync( AdminShowClusterOperationsRequest request_,
                                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        AdminShowClusterOperationsResponse actualResponse_ = await SubmitRequestAsync<AdminShowClusterOperationsResponse>("/admin/show/cluster/operations", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminShowClusterOperationsResponse adminShowClusterOperations( int history_index = 0,
                                                                          IDictionary<string, string> options = null )
    {
        return adminShowClusterOperations( new AdminShowClusterOperationsRequest( history_index,
                                                                                  options ) );
    }

    public async System.Threading.Tasks.Task<AdminShowClusterOperationsResponse> AdminShowClusterOperationsAsync( int history_index = 0,
                                                                                                                  IDictionary<string, string> options = null,
                                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminShowClusterOperationsAsync( new AdminShowClusterOperationsRequest( history_index,
                                                                                             options ), cancellationToken );
    }

    public AdminShowJobsResponse adminShowJobs( AdminShowJobsRequest request_ )
    {
        AdminShowJobsResponse actualResponse_ = SubmitRequest<AdminShowJobsResponse>("/admin/show/jobs", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminShowJobsResponse> AdminShowJobsAsync( AdminShowJobsRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        AdminShowJobsResponse actualResponse_ = await SubmitRequestAsync<AdminShowJobsResponse>("/admin/show/jobs", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminShowJobsResponse adminShowJobs( IDictionary<string, string> options = null )
    {
        return adminShowJobs( new AdminShowJobsRequest( options ) );
    }

    public async System.Threading.Tasks.Task<AdminShowJobsResponse> AdminShowJobsAsync( IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminShowJobsAsync( new AdminShowJobsRequest( options ), cancellationToken );
    }

    public AdminShowShardsResponse adminShowShards( AdminShowShardsRequest request_ )
    {
        AdminShowShardsResponse actualResponse_ = SubmitRequest<AdminShowShardsResponse>("/admin/show/shards", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminShowShardsResponse> AdminShowShardsAsync( AdminShowShardsRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        AdminShowShardsResponse actualResponse_ = await SubmitRequestAsync<AdminShowShardsResponse>("/admin/show/shards", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminShowShardsResponse adminShowShards( IDictionary<string, string> options = null )
    {
        return adminShowShards( new AdminShowShardsRequest( options ) );
    }

    public async System.Threading.Tasks.Task<AdminShowShardsResponse> AdminShowShardsAsync( IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminShowShardsAsync( new AdminShowShardsRequest( options ), cancellationToken );
    }

    public AdminShutdownResponse adminShutdown( AdminShutdownRequest request_ )
    {
        AdminShutdownResponse actualResponse_ = SubmitRequest<AdminShutdownResponse>("/admin/shutdown", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminShutdownResponse> AdminShutdownAsync( AdminShutdownRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        AdminShutdownResponse actualResponse_ = await SubmitRequestAsync<AdminShutdownResponse>("/admin/shutdown", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminShutdownResponse adminShutdown( string exit_type,
                                                string authorization,
                                                IDictionary<string, string> options = null )
    {
        return adminShutdown( new AdminShutdownRequest( exit_type, authorization, options ) );
    }

    public async System.Threading.Tasks.Task<AdminShutdownResponse> AdminShutdownAsync( string exit_type,
                                                                                        string authorization,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminShutdownAsync( new AdminShutdownRequest( exit_type,
                                                                   authorization, options ), cancellationToken );
    }

    public AdminSwitchoverResponse adminSwitchover( AdminSwitchoverRequest request_ )
    {
        AdminSwitchoverResponse actualResponse_ = SubmitRequest<AdminSwitchoverResponse>("/admin/switchover", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminSwitchoverResponse> AdminSwitchoverAsync( AdminSwitchoverRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        AdminSwitchoverResponse actualResponse_ = await SubmitRequestAsync<AdminSwitchoverResponse>("/admin/switchover", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminSwitchoverResponse adminSwitchover( IList<string> processes,
                                                    IList<string> destinations,
                                                    IDictionary<string, string> options = null )
    {
        return adminSwitchover( new AdminSwitchoverRequest( processes, destinations,
                                                            options ) );
    }

    public async System.Threading.Tasks.Task<AdminSwitchoverResponse> AdminSwitchoverAsync( IList<string> processes,
                                                                                            IList<string> destinations,
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminSwitchoverAsync( new AdminSwitchoverRequest( processes,
                                                                       destinations,
                                                                       options ), cancellationToken );
    }

    public AdminVerifyDbResponse adminVerifyDb( AdminVerifyDbRequest request_ )
    {
        AdminVerifyDbResponse actualResponse_ = SubmitRequest<AdminVerifyDbResponse>("/admin/verifydb", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AdminVerifyDbResponse> AdminVerifyDbAsync( AdminVerifyDbRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        AdminVerifyDbResponse actualResponse_ = await SubmitRequestAsync<AdminVerifyDbResponse>("/admin/verifydb", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AdminVerifyDbResponse adminVerifyDb( IDictionary<string, string> options = null )
    {
        return adminVerifyDb( new AdminVerifyDbRequest( options ) );
    }

    public async System.Threading.Tasks.Task<AdminVerifyDbResponse> AdminVerifyDbAsync( IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await AdminVerifyDbAsync( new AdminVerifyDbRequest( options ), cancellationToken );
    }

    public AggregateConvexHullResponse aggregateConvexHull( AggregateConvexHullRequest request_ )
    {
        AggregateConvexHullResponse actualResponse_ = SubmitRequest<AggregateConvexHullResponse>("/aggregate/convexhull", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AggregateConvexHullResponse> AggregateConvexHullAsync( AggregateConvexHullRequest request_,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        AggregateConvexHullResponse actualResponse_ = await SubmitRequestAsync<AggregateConvexHullResponse>("/aggregate/convexhull", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AggregateConvexHullResponse aggregateConvexHull( string table_name,
                                                            string x_column_name,
                                                            string y_column_name,
                                                            IDictionary<string, string> options = null )
    {
        return aggregateConvexHull( new AggregateConvexHullRequest( table_name,
                                                                    x_column_name,
                                                                    y_column_name, options ) );
    }

    public async System.Threading.Tasks.Task<AggregateConvexHullResponse> AggregateConvexHullAsync( string table_name,
                                                                                                    string x_column_name,
                                                                                                    string y_column_name,
                                                                                                    IDictionary<string, string> options = null,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await AggregateConvexHullAsync( new AggregateConvexHullRequest( table_name,
                                                                               x_column_name,
                                                                               y_column_name,
                                                                               options ), cancellationToken );
    }

    public AggregateGroupByResponse aggregateGroupBy( AggregateGroupByRequest request_ )
    {
        RawAggregateGroupByResponse actualResponse_ = SubmitRequest<RawAggregateGroupByResponse>("/aggregate/groupby", request_, false);

        AggregateGroupByResponse response_ = new AggregateGroupByResponse();
        response_.data = KineticaRecord.DecodeDynamicTableRecords( actualResponse_.response_schema_str, actualResponse_.binary_encoded_response );
        response_.total_number_of_records = actualResponse_.total_number_of_records;
        response_.has_more_records = actualResponse_.has_more_records;
        response_.info = actualResponse_.info;
        return response_;
    }

    public async System.Threading.Tasks.Task<AggregateGroupByResponse> AggregateGroupByAsync( AggregateGroupByRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        RawAggregateGroupByResponse actualResponse_ = await SubmitRequestAsync<RawAggregateGroupByResponse>("/aggregate/groupby", request_, false, true, cancellationToken);

        AggregateGroupByResponse response_ = new AggregateGroupByResponse();
        response_.data = KineticaRecord.DecodeDynamicTableRecords( actualResponse_.response_schema_str, actualResponse_.binary_encoded_response );
        response_.total_number_of_records = actualResponse_.total_number_of_records;
        response_.has_more_records = actualResponse_.has_more_records;
        response_.info = actualResponse_.info;
        return response_;
    }

    public AggregateGroupByResponse aggregateGroupBy( string table_name,
                                                      IList<string> column_names,
                                                      long offset = 0,
                                                      long limit = -9999,
                                                      IDictionary<string, string> options = null )
    {
        return aggregateGroupBy( new AggregateGroupByRequest( table_name, column_names,
                                                              offset, limit, options ) );
    }

    public async System.Threading.Tasks.Task<AggregateGroupByResponse> AggregateGroupByAsync( string table_name,
                                                                                              IList<string> column_names,
                                                                                              long offset = 0,
                                                                                              long limit = -9999,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await AggregateGroupByAsync( new AggregateGroupByRequest( table_name,
                                                                         column_names,
                                                                         offset, limit,
                                                                         options ), cancellationToken );
    }

    public AggregateHistogramResponse aggregateHistogram( AggregateHistogramRequest request_ )
    {
        AggregateHistogramResponse actualResponse_ = SubmitRequest<AggregateHistogramResponse>("/aggregate/histogram", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AggregateHistogramResponse> AggregateHistogramAsync( AggregateHistogramRequest request_,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        AggregateHistogramResponse actualResponse_ = await SubmitRequestAsync<AggregateHistogramResponse>("/aggregate/histogram", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AggregateHistogramResponse aggregateHistogram( string table_name,
                                                          string column_name,
                                                          double start,
                                                          double end,
                                                          double interval,
                                                          IDictionary<string, string> options = null )
    {
        return aggregateHistogram( new AggregateHistogramRequest( table_name, column_name,
                                                                  start, end, interval,
                                                                  options ) );
    }

    public async System.Threading.Tasks.Task<AggregateHistogramResponse> AggregateHistogramAsync( string table_name,
                                                                                                  string column_name,
                                                                                                  double start,
                                                                                                  double end,
                                                                                                  double interval,
                                                                                                  IDictionary<string, string> options = null,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await AggregateHistogramAsync( new AggregateHistogramRequest( table_name,
                                                                             column_name,
                                                                             start, end,
                                                                             interval,
                                                                             options ), cancellationToken );
    }

    public AggregateKMeansResponse aggregateKMeans( AggregateKMeansRequest request_ )
    {
        AggregateKMeansResponse actualResponse_ = SubmitRequest<AggregateKMeansResponse>("/aggregate/kmeans", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AggregateKMeansResponse> AggregateKMeansAsync( AggregateKMeansRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        AggregateKMeansResponse actualResponse_ = await SubmitRequestAsync<AggregateKMeansResponse>("/aggregate/kmeans", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AggregateKMeansResponse aggregateKMeans( string table_name,
                                                    IList<string> column_names,
                                                    int k,
                                                    double tolerance,
                                                    IDictionary<string, string> options = null )
    {
        return aggregateKMeans( new AggregateKMeansRequest( table_name, column_names, k,
                                                            tolerance, options ) );
    }

    public async System.Threading.Tasks.Task<AggregateKMeansResponse> AggregateKMeansAsync( string table_name,
                                                                                            IList<string> column_names,
                                                                                            int k,
                                                                                            double tolerance,
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await AggregateKMeansAsync( new AggregateKMeansRequest( table_name,
                                                                       column_names, k,
                                                                       tolerance, options ), cancellationToken );
    }

    public AggregateMinMaxResponse aggregateMinMax( AggregateMinMaxRequest request_ )
    {
        AggregateMinMaxResponse actualResponse_ = SubmitRequest<AggregateMinMaxResponse>("/aggregate/minmax", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AggregateMinMaxResponse> AggregateMinMaxAsync( AggregateMinMaxRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        AggregateMinMaxResponse actualResponse_ = await SubmitRequestAsync<AggregateMinMaxResponse>("/aggregate/minmax", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AggregateMinMaxResponse aggregateMinMax( string table_name,
                                                    string column_name,
                                                    IDictionary<string, string> options = null )
    {
        return aggregateMinMax( new AggregateMinMaxRequest( table_name, column_name,
                                                            options ) );
    }

    public async System.Threading.Tasks.Task<AggregateMinMaxResponse> AggregateMinMaxAsync( string table_name,
                                                                                            string column_name,
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await AggregateMinMaxAsync( new AggregateMinMaxRequest( table_name,
                                                                       column_name,
                                                                       options ), cancellationToken );
    }

    public AggregateMinMaxGeometryResponse aggregateMinMaxGeometry( AggregateMinMaxGeometryRequest request_ )
    {
        AggregateMinMaxGeometryResponse actualResponse_ = SubmitRequest<AggregateMinMaxGeometryResponse>("/aggregate/minmax/geometry", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AggregateMinMaxGeometryResponse> AggregateMinMaxGeometryAsync( AggregateMinMaxGeometryRequest request_,
                                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        AggregateMinMaxGeometryResponse actualResponse_ = await SubmitRequestAsync<AggregateMinMaxGeometryResponse>("/aggregate/minmax/geometry", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AggregateMinMaxGeometryResponse aggregateMinMaxGeometry( string table_name,
                                                                    string column_name,
                                                                    IDictionary<string, string> options = null )
    {
        return aggregateMinMaxGeometry( new AggregateMinMaxGeometryRequest( table_name,
                                                                            column_name,
                                                                            options ) );
    }

    public async System.Threading.Tasks.Task<AggregateMinMaxGeometryResponse> AggregateMinMaxGeometryAsync( string table_name,
                                                                                                            string column_name,
                                                                                                            IDictionary<string, string> options = null,
                                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await AggregateMinMaxGeometryAsync( new AggregateMinMaxGeometryRequest( table_name,
                                                                                       column_name,
                                                                                       options ), cancellationToken );
    }

    public AggregateStatisticsResponse aggregateStatistics( AggregateStatisticsRequest request_ )
    {
        AggregateStatisticsResponse actualResponse_ = SubmitRequest<AggregateStatisticsResponse>("/aggregate/statistics", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AggregateStatisticsResponse> AggregateStatisticsAsync( AggregateStatisticsRequest request_,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        AggregateStatisticsResponse actualResponse_ = await SubmitRequestAsync<AggregateStatisticsResponse>("/aggregate/statistics", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AggregateStatisticsResponse aggregateStatistics( string table_name,
                                                            string column_name,
                                                            string stats,
                                                            IDictionary<string, string> options = null )
    {
        return aggregateStatistics( new AggregateStatisticsRequest( table_name,
                                                                    column_name, stats,
                                                                    options ) );
    }

    public async System.Threading.Tasks.Task<AggregateStatisticsResponse> AggregateStatisticsAsync( string table_name,
                                                                                                    string column_name,
                                                                                                    string stats,
                                                                                                    IDictionary<string, string> options = null,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await AggregateStatisticsAsync( new AggregateStatisticsRequest( table_name,
                                                                               column_name,
                                                                               stats,
                                                                               options ), cancellationToken );
    }

    public AggregateStatisticsByRangeResponse aggregateStatisticsByRange( AggregateStatisticsByRangeRequest request_ )
    {
        AggregateStatisticsByRangeResponse actualResponse_ = SubmitRequest<AggregateStatisticsByRangeResponse>("/aggregate/statistics/byrange", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AggregateStatisticsByRangeResponse> AggregateStatisticsByRangeAsync( AggregateStatisticsByRangeRequest request_,
                                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        AggregateStatisticsByRangeResponse actualResponse_ = await SubmitRequestAsync<AggregateStatisticsByRangeResponse>("/aggregate/statistics/byrange", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AggregateStatisticsByRangeResponse aggregateStatisticsByRange( string table_name,
                                                                          string select_expression,
                                                                          string column_name,
                                                                          string value_column_name,
                                                                          string stats,
                                                                          double start,
                                                                          double end,
                                                                          double interval,
                                                                          IDictionary<string, string> options = null )
    {
        return aggregateStatisticsByRange( new AggregateStatisticsByRangeRequest( table_name,
                                                                                  select_expression,
                                                                                  column_name,
                                                                                  value_column_name,
                                                                                  stats,
                                                                                  start,
                                                                                  end,
                                                                                  interval,
                                                                                  options ) );
    }

    public async System.Threading.Tasks.Task<AggregateStatisticsByRangeResponse> AggregateStatisticsByRangeAsync( string table_name,
                                                                                                                  string select_expression,
                                                                                                                  string column_name,
                                                                                                                  string value_column_name,
                                                                                                                  string stats,
                                                                                                                  double start,
                                                                                                                  double end,
                                                                                                                  double interval,
                                                                                                                  IDictionary<string, string> options = null,
                                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await AggregateStatisticsByRangeAsync( new AggregateStatisticsByRangeRequest( table_name,
                                                                                             select_expression,
                                                                                             column_name,
                                                                                             value_column_name,
                                                                                             stats,
                                                                                             start,
                                                                                             end,
                                                                                             interval,
                                                                                             options ), cancellationToken );
    }

    public AggregateUniqueResponse aggregateUnique( AggregateUniqueRequest request_ )
    {
        RawAggregateUniqueResponse actualResponse_ = SubmitRequest<RawAggregateUniqueResponse>("/aggregate/unique", request_, false);

        AggregateUniqueResponse response_ = new AggregateUniqueResponse();
        response_.table_name = actualResponse_.table_name;
        response_.data = KineticaRecord.DecodeDynamicTableRecords( actualResponse_.response_schema_str, actualResponse_.binary_encoded_response );
        response_.has_more_records = actualResponse_.has_more_records;
        response_.info = actualResponse_.info;
        return response_;
    }

    public async System.Threading.Tasks.Task<AggregateUniqueResponse> AggregateUniqueAsync( AggregateUniqueRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        RawAggregateUniqueResponse actualResponse_ = await SubmitRequestAsync<RawAggregateUniqueResponse>("/aggregate/unique", request_, false, true, cancellationToken);

        AggregateUniqueResponse response_ = new AggregateUniqueResponse();
        response_.table_name = actualResponse_.table_name;
        response_.data = KineticaRecord.DecodeDynamicTableRecords( actualResponse_.response_schema_str, actualResponse_.binary_encoded_response );
        response_.has_more_records = actualResponse_.has_more_records;
        response_.info = actualResponse_.info;
        return response_;
    }

    public AggregateUniqueResponse aggregateUnique( string table_name,
                                                    string column_name,
                                                    long offset = 0,
                                                    long limit = -9999,
                                                    IDictionary<string, string> options = null )
    {
        return aggregateUnique( new AggregateUniqueRequest( table_name, column_name,
                                                            offset, limit, options ) );
    }

    public async System.Threading.Tasks.Task<AggregateUniqueResponse> AggregateUniqueAsync( string table_name,
                                                                                            string column_name,
                                                                                            long offset = 0,
                                                                                            long limit = -9999,
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await AggregateUniqueAsync( new AggregateUniqueRequest( table_name,
                                                                       column_name,
                                                                       offset, limit,
                                                                       options ), cancellationToken );
    }

    public AggregateUnpivotResponse aggregateUnpivot( AggregateUnpivotRequest request_ )
    {
        RawAggregateUnpivotResponse actualResponse_ = SubmitRequest<RawAggregateUnpivotResponse>("/aggregate/unpivot", request_, false);

        AggregateUnpivotResponse response_ = new AggregateUnpivotResponse();
        response_.table_name = actualResponse_.table_name;
        response_.data = KineticaRecord.DecodeDynamicTableRecords( actualResponse_.response_schema_str, actualResponse_.binary_encoded_response );
        response_.total_number_of_records = actualResponse_.total_number_of_records;
        response_.has_more_records = actualResponse_.has_more_records;
        response_.info = actualResponse_.info;
        return response_;
    }

    public async System.Threading.Tasks.Task<AggregateUnpivotResponse> AggregateUnpivotAsync( AggregateUnpivotRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        RawAggregateUnpivotResponse actualResponse_ = await SubmitRequestAsync<RawAggregateUnpivotResponse>("/aggregate/unpivot", request_, false, true, cancellationToken);

        AggregateUnpivotResponse response_ = new AggregateUnpivotResponse();
        response_.table_name = actualResponse_.table_name;
        response_.data = KineticaRecord.DecodeDynamicTableRecords( actualResponse_.response_schema_str, actualResponse_.binary_encoded_response );
        response_.total_number_of_records = actualResponse_.total_number_of_records;
        response_.has_more_records = actualResponse_.has_more_records;
        response_.info = actualResponse_.info;
        return response_;
    }

    public AggregateUnpivotResponse aggregateUnpivot( string table_name,
                                                      IList<string> column_names,
                                                      string variable_column_name,
                                                      string value_column_name,
                                                      IList<string> pivoted_columns,
                                                      IDictionary<string, string> options = null )
    {
        return aggregateUnpivot( new AggregateUnpivotRequest( table_name, column_names,
                                                              variable_column_name,
                                                              value_column_name,
                                                              pivoted_columns, options ) );
    }

    public async System.Threading.Tasks.Task<AggregateUnpivotResponse> AggregateUnpivotAsync( string table_name,
                                                                                              IList<string> column_names,
                                                                                              string variable_column_name,
                                                                                              string value_column_name,
                                                                                              IList<string> pivoted_columns,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await AggregateUnpivotAsync( new AggregateUnpivotRequest( table_name,
                                                                         column_names,
                                                                         variable_column_name,
                                                                         value_column_name,
                                                                         pivoted_columns,
                                                                         options ), cancellationToken );
    }

    public AlterBackupResponse alterBackup( AlterBackupRequest request_ )
    {
        AlterBackupResponse actualResponse_ = SubmitRequest<AlterBackupResponse>("/alter/backup", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterBackupResponse> AlterBackupAsync( AlterBackupRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        AlterBackupResponse actualResponse_ = await SubmitRequestAsync<AlterBackupResponse>("/alter/backup", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterBackupResponse alterBackup( string backup_name,
                                            string action,
                                            string _value,
                                            string datasink_name,
                                            IDictionary<string, string> options = null )
    {
        return alterBackup( new AlterBackupRequest( backup_name, action, _value,
                                                    datasink_name, options ) );
    }

    public async System.Threading.Tasks.Task<AlterBackupResponse> AlterBackupAsync( string backup_name,
                                                                                    string action,
                                                                                    string _value,
                                                                                    string datasink_name,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterBackupAsync( new AlterBackupRequest( backup_name, action,
                                                               _value, datasink_name,
                                                               options ), cancellationToken );
    }

    public AlterCredentialResponse alterCredential( AlterCredentialRequest request_ )
    {
        AlterCredentialResponse actualResponse_ = SubmitRequest<AlterCredentialResponse>("/alter/credential", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterCredentialResponse> AlterCredentialAsync( AlterCredentialRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        AlterCredentialResponse actualResponse_ = await SubmitRequestAsync<AlterCredentialResponse>("/alter/credential", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterCredentialResponse alterCredential( string credential_name,
                                                    IDictionary<string, string> credential_updates_map,
                                                    IDictionary<string, string> options )
    {
        return alterCredential( new AlterCredentialRequest( credential_name,
                                                            credential_updates_map,
                                                            options ) );
    }

    public async System.Threading.Tasks.Task<AlterCredentialResponse> AlterCredentialAsync( string credential_name,
                                                                                            IDictionary<string, string> credential_updates_map,
                                                                                            IDictionary<string, string> options,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterCredentialAsync( new AlterCredentialRequest( credential_name,
                                                                       credential_updates_map,
                                                                       options ), cancellationToken );
    }

    public AlterDatasinkResponse alterDatasink( AlterDatasinkRequest request_ )
    {
        AlterDatasinkResponse actualResponse_ = SubmitRequest<AlterDatasinkResponse>("/alter/datasink", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterDatasinkResponse> AlterDatasinkAsync( AlterDatasinkRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        AlterDatasinkResponse actualResponse_ = await SubmitRequestAsync<AlterDatasinkResponse>("/alter/datasink", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterDatasinkResponse alterDatasink( string name,
                                                IDictionary<string, string> datasink_updates_map,
                                                IDictionary<string, string> options )
    {
        return alterDatasink( new AlterDatasinkRequest( name, datasink_updates_map,
                                                        options ) );
    }

    public async System.Threading.Tasks.Task<AlterDatasinkResponse> AlterDatasinkAsync( string name,
                                                                                        IDictionary<string, string> datasink_updates_map,
                                                                                        IDictionary<string, string> options,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterDatasinkAsync( new AlterDatasinkRequest( name,
                                                                   datasink_updates_map,
                                                                   options ), cancellationToken );
    }

    public AlterDatasourceResponse alterDatasource( AlterDatasourceRequest request_ )
    {
        AlterDatasourceResponse actualResponse_ = SubmitRequest<AlterDatasourceResponse>("/alter/datasource", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterDatasourceResponse> AlterDatasourceAsync( AlterDatasourceRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        AlterDatasourceResponse actualResponse_ = await SubmitRequestAsync<AlterDatasourceResponse>("/alter/datasource", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterDatasourceResponse alterDatasource( string name,
                                                    IDictionary<string, string> datasource_updates_map,
                                                    IDictionary<string, string> options )
    {
        return alterDatasource( new AlterDatasourceRequest( name, datasource_updates_map,
                                                            options ) );
    }

    public async System.Threading.Tasks.Task<AlterDatasourceResponse> AlterDatasourceAsync( string name,
                                                                                            IDictionary<string, string> datasource_updates_map,
                                                                                            IDictionary<string, string> options,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterDatasourceAsync( new AlterDatasourceRequest( name,
                                                                       datasource_updates_map,
                                                                       options ), cancellationToken );
    }

    public AlterDirectoryResponse alterDirectory( AlterDirectoryRequest request_ )
    {
        AlterDirectoryResponse actualResponse_ = SubmitRequest<AlterDirectoryResponse>("/alter/directory", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterDirectoryResponse> AlterDirectoryAsync( AlterDirectoryRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        AlterDirectoryResponse actualResponse_ = await SubmitRequestAsync<AlterDirectoryResponse>("/alter/directory", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterDirectoryResponse alterDirectory( string directory_name,
                                                  IDictionary<string, string> directory_updates_map,
                                                  IDictionary<string, string> options = null )
    {
        return alterDirectory( new AlterDirectoryRequest( directory_name,
                                                          directory_updates_map, options ) );
    }

    public async System.Threading.Tasks.Task<AlterDirectoryResponse> AlterDirectoryAsync( string directory_name,
                                                                                          IDictionary<string, string> directory_updates_map,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterDirectoryAsync( new AlterDirectoryRequest( directory_name,
                                                                     directory_updates_map,
                                                                     options ), cancellationToken );
    }

    public AlterEnvironmentResponse alterEnvironment( AlterEnvironmentRequest request_ )
    {
        AlterEnvironmentResponse actualResponse_ = SubmitRequest<AlterEnvironmentResponse>("/alter/environment", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterEnvironmentResponse> AlterEnvironmentAsync( AlterEnvironmentRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        AlterEnvironmentResponse actualResponse_ = await SubmitRequestAsync<AlterEnvironmentResponse>("/alter/environment", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterEnvironmentResponse alterEnvironment( string environment_name,
                                                      string action,
                                                      string _value,
                                                      IDictionary<string, string> options = null )
    {
        return alterEnvironment( new AlterEnvironmentRequest( environment_name, action,
                                                              _value, options ) );
    }

    public async System.Threading.Tasks.Task<AlterEnvironmentResponse> AlterEnvironmentAsync( string environment_name,
                                                                                              string action,
                                                                                              string _value,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterEnvironmentAsync( new AlterEnvironmentRequest( environment_name,
                                                                         action, _value,
                                                                         options ), cancellationToken );
    }

    public AlterGraphResponse alterGraph( AlterGraphRequest request_ )
    {
        AlterGraphResponse actualResponse_ = SubmitRequest<AlterGraphResponse>("/alter/graph", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterGraphResponse> AlterGraphAsync( AlterGraphRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        AlterGraphResponse actualResponse_ = await SubmitRequestAsync<AlterGraphResponse>("/alter/graph", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterGraphResponse alterGraph( string graph_name,
                                          string action,
                                          string action_arg,
                                          IDictionary<string, string> options = null )
    {
        return alterGraph( new AlterGraphRequest( graph_name, action, action_arg, options ) );
    }

    public async System.Threading.Tasks.Task<AlterGraphResponse> AlterGraphAsync( string graph_name,
                                                                                  string action,
                                                                                  string action_arg,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterGraphAsync( new AlterGraphRequest( graph_name, action,
                                                             action_arg, options ), cancellationToken );
    }

    public AlterModelResponse alterModel( AlterModelRequest request_ )
    {
        AlterModelResponse actualResponse_ = SubmitRequest<AlterModelResponse>("/alter/model", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterModelResponse> AlterModelAsync( AlterModelRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        AlterModelResponse actualResponse_ = await SubmitRequestAsync<AlterModelResponse>("/alter/model", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterModelResponse alterModel( string model_name,
                                          string action,
                                          string _value,
                                          IDictionary<string, string> options = null )
    {
        return alterModel( new AlterModelRequest( model_name, action, _value, options ) );
    }

    public async System.Threading.Tasks.Task<AlterModelResponse> AlterModelAsync( string model_name,
                                                                                  string action,
                                                                                  string _value,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterModelAsync( new AlterModelRequest( model_name, action, _value,
                                                             options ), cancellationToken );
    }

    public AlterResourceGroupResponse alterResourceGroup( AlterResourceGroupRequest request_ )
    {
        AlterResourceGroupResponse actualResponse_ = SubmitRequest<AlterResourceGroupResponse>("/alter/resourcegroup", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterResourceGroupResponse> AlterResourceGroupAsync( AlterResourceGroupRequest request_,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        AlterResourceGroupResponse actualResponse_ = await SubmitRequestAsync<AlterResourceGroupResponse>("/alter/resourcegroup", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterResourceGroupResponse alterResourceGroup( string name,
                                                          IDictionary<string, IDictionary<string, string>> tier_attributes = null,
                                                          string ranking = AlterResourceGroupRequest.Ranking.EMPTY_STRING,
                                                          string adjoining_resource_group = "",
                                                          IDictionary<string, string> options = null )
    {
        return alterResourceGroup( new AlterResourceGroupRequest( name, tier_attributes,
                                                                  ranking,
                                                                  adjoining_resource_group,
                                                                  options ) );
    }

    public async System.Threading.Tasks.Task<AlterResourceGroupResponse> AlterResourceGroupAsync( string name,
                                                                                                  IDictionary<string, IDictionary<string, string>> tier_attributes = null,
                                                                                                  string ranking = AlterResourceGroupRequest.Ranking.EMPTY_STRING,
                                                                                                  string adjoining_resource_group = "",
                                                                                                  IDictionary<string, string> options = null,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterResourceGroupAsync( new AlterResourceGroupRequest( name,
                                                                             tier_attributes,
                                                                             ranking,
                                                                             adjoining_resource_group,
                                                                             options ), cancellationToken );
    }

    public AlterRoleResponse alterRole( AlterRoleRequest request_ )
    {
        AlterRoleResponse actualResponse_ = SubmitRequest<AlterRoleResponse>("/alter/role", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterRoleResponse> AlterRoleAsync( AlterRoleRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        AlterRoleResponse actualResponse_ = await SubmitRequestAsync<AlterRoleResponse>("/alter/role", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterRoleResponse alterRole( string name,
                                        string action,
                                        string _value,
                                        IDictionary<string, string> options = null )
    {
        return alterRole( new AlterRoleRequest( name, action, _value, options ) );
    }

    public async System.Threading.Tasks.Task<AlterRoleResponse> AlterRoleAsync( string name,
                                                                                string action,
                                                                                string _value,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterRoleAsync( new AlterRoleRequest( name, action, _value, options ), cancellationToken );
    }

    public AlterSchemaResponse alterSchema( AlterSchemaRequest request_ )
    {
        AlterSchemaResponse actualResponse_ = SubmitRequest<AlterSchemaResponse>("/alter/schema", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterSchemaResponse> AlterSchemaAsync( AlterSchemaRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        AlterSchemaResponse actualResponse_ = await SubmitRequestAsync<AlterSchemaResponse>("/alter/schema", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterSchemaResponse alterSchema( string schema_name,
                                            string action,
                                            string _value,
                                            IDictionary<string, string> options = null )
    {
        return alterSchema( new AlterSchemaRequest( schema_name, action, _value, options ) );
    }

    public async System.Threading.Tasks.Task<AlterSchemaResponse> AlterSchemaAsync( string schema_name,
                                                                                    string action,
                                                                                    string _value,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterSchemaAsync( new AlterSchemaRequest( schema_name, action,
                                                               _value, options ), cancellationToken );
    }

    public AlterSystemPropertiesResponse alterSystemProperties( AlterSystemPropertiesRequest request_ )
    {
        AlterSystemPropertiesResponse actualResponse_ = SubmitRequest<AlterSystemPropertiesResponse>("/alter/system/properties", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterSystemPropertiesResponse> AlterSystemPropertiesAsync( AlterSystemPropertiesRequest request_,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        AlterSystemPropertiesResponse actualResponse_ = await SubmitRequestAsync<AlterSystemPropertiesResponse>("/alter/system/properties", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterSystemPropertiesResponse alterSystemProperties( IDictionary<string, string> property_updates_map,
                                                                IDictionary<string, string> options = null )
    {
        return alterSystemProperties( new AlterSystemPropertiesRequest( property_updates_map,
                                                                        options ) );
    }

    public async System.Threading.Tasks.Task<AlterSystemPropertiesResponse> AlterSystemPropertiesAsync( IDictionary<string, string> property_updates_map,
                                                                                                        IDictionary<string, string> options = null,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterSystemPropertiesAsync( new AlterSystemPropertiesRequest( property_updates_map,
                                                                                   options ), cancellationToken );
    }

    public AlterTableResponse alterTable( AlterTableRequest request_ )
    {
        AlterTableResponse actualResponse_ = SubmitRequest<AlterTableResponse>("/alter/table", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterTableResponse> AlterTableAsync( AlterTableRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        AlterTableResponse actualResponse_ = await SubmitRequestAsync<AlterTableResponse>("/alter/table", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterTableResponse alterTable( string table_name,
                                          string action,
                                          string _value,
                                          IDictionary<string, string> options = null )
    {
        return alterTable( new AlterTableRequest( table_name, action, _value, options ) );
    }

    public async System.Threading.Tasks.Task<AlterTableResponse> AlterTableAsync( string table_name,
                                                                                  string action,
                                                                                  string _value,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterTableAsync( new AlterTableRequest( table_name, action, _value,
                                                             options ), cancellationToken );
    }

    public AlterTableColumnsResponse alterTableColumns( AlterTableColumnsRequest request_ )
    {
        AlterTableColumnsResponse actualResponse_ = SubmitRequest<AlterTableColumnsResponse>("/alter/table/columns", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterTableColumnsResponse> AlterTableColumnsAsync( AlterTableColumnsRequest request_,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        AlterTableColumnsResponse actualResponse_ = await SubmitRequestAsync<AlterTableColumnsResponse>("/alter/table/columns", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterTableColumnsResponse alterTableColumns( string table_name,
                                                        IList<IDictionary<string, string>> column_alterations,
                                                        IDictionary<string, string> options )
    {
        return alterTableColumns( new AlterTableColumnsRequest( table_name,
                                                                column_alterations,
                                                                options ) );
    }

    public async System.Threading.Tasks.Task<AlterTableColumnsResponse> AlterTableColumnsAsync( string table_name,
                                                                                                IList<IDictionary<string, string>> column_alterations,
                                                                                                IDictionary<string, string> options,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterTableColumnsAsync( new AlterTableColumnsRequest( table_name,
                                                                           column_alterations,
                                                                           options ), cancellationToken );
    }

    public AlterTableMetadataResponse alterTableMetadata( AlterTableMetadataRequest request_ )
    {
        AlterTableMetadataResponse actualResponse_ = SubmitRequest<AlterTableMetadataResponse>("/alter/table/metadata", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterTableMetadataResponse> AlterTableMetadataAsync( AlterTableMetadataRequest request_,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        AlterTableMetadataResponse actualResponse_ = await SubmitRequestAsync<AlterTableMetadataResponse>("/alter/table/metadata", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterTableMetadataResponse alterTableMetadata( IList<string> table_names,
                                                          IDictionary<string, string> metadata_map,
                                                          IDictionary<string, string> options = null )
    {
        return alterTableMetadata( new AlterTableMetadataRequest( table_names,
                                                                  metadata_map, options ) );
    }

    public async System.Threading.Tasks.Task<AlterTableMetadataResponse> AlterTableMetadataAsync( IList<string> table_names,
                                                                                                  IDictionary<string, string> metadata_map,
                                                                                                  IDictionary<string, string> options = null,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterTableMetadataAsync( new AlterTableMetadataRequest( table_names,
                                                                             metadata_map,
                                                                             options ), cancellationToken );
    }

    public AlterTableMonitorResponse alterTableMonitor( AlterTableMonitorRequest request_ )
    {
        AlterTableMonitorResponse actualResponse_ = SubmitRequest<AlterTableMonitorResponse>("/alter/tablemonitor", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterTableMonitorResponse> AlterTableMonitorAsync( AlterTableMonitorRequest request_,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        AlterTableMonitorResponse actualResponse_ = await SubmitRequestAsync<AlterTableMonitorResponse>("/alter/tablemonitor", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterTableMonitorResponse alterTableMonitor( string topic_id,
                                                        IDictionary<string, string> monitor_updates_map,
                                                        IDictionary<string, string> options = null )
    {
        return alterTableMonitor( new AlterTableMonitorRequest( topic_id,
                                                                monitor_updates_map,
                                                                options ) );
    }

    public async System.Threading.Tasks.Task<AlterTableMonitorResponse> AlterTableMonitorAsync( string topic_id,
                                                                                                IDictionary<string, string> monitor_updates_map,
                                                                                                IDictionary<string, string> options = null,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterTableMonitorAsync( new AlterTableMonitorRequest( topic_id,
                                                                           monitor_updates_map,
                                                                           options ), cancellationToken );
    }

    public AlterTierResponse alterTier( AlterTierRequest request_ )
    {
        AlterTierResponse actualResponse_ = SubmitRequest<AlterTierResponse>("/alter/tier", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterTierResponse> AlterTierAsync( AlterTierRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        AlterTierResponse actualResponse_ = await SubmitRequestAsync<AlterTierResponse>("/alter/tier", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterTierResponse alterTier( string name,
                                        IDictionary<string, string> options = null )
    {
        return alterTier( new AlterTierRequest( name, options ) );
    }

    public async System.Threading.Tasks.Task<AlterTierResponse> AlterTierAsync( string name,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterTierAsync( new AlterTierRequest( name, options ), cancellationToken );
    }

    public AlterUserResponse alterUser( AlterUserRequest request_ )
    {
        AlterUserResponse actualResponse_ = SubmitRequest<AlterUserResponse>("/alter/user", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterUserResponse> AlterUserAsync( AlterUserRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        AlterUserResponse actualResponse_ = await SubmitRequestAsync<AlterUserResponse>("/alter/user", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterUserResponse alterUser( string name,
                                        string action,
                                        string _value,
                                        IDictionary<string, string> options = null )
    {
        return alterUser( new AlterUserRequest( name, action, _value, options ) );
    }

    public async System.Threading.Tasks.Task<AlterUserResponse> AlterUserAsync( string name,
                                                                                string action,
                                                                                string _value,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterUserAsync( new AlterUserRequest( name, action, _value, options ), cancellationToken );
    }

    public AlterVideoResponse alterVideo( AlterVideoRequest request_ )
    {
        AlterVideoResponse actualResponse_ = SubmitRequest<AlterVideoResponse>("/alter/video", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterVideoResponse> AlterVideoAsync( AlterVideoRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        AlterVideoResponse actualResponse_ = await SubmitRequestAsync<AlterVideoResponse>("/alter/video", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterVideoResponse alterVideo( string path,
                                          IDictionary<string, string> options = null )
    {
        return alterVideo( new AlterVideoRequest( path, options ) );
    }

    public async System.Threading.Tasks.Task<AlterVideoResponse> AlterVideoAsync( string path,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterVideoAsync( new AlterVideoRequest( path, options ), cancellationToken );
    }

    public AlterWalResponse alterWal( AlterWalRequest request_ )
    {
        AlterWalResponse actualResponse_ = SubmitRequest<AlterWalResponse>("/alter/wal", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AlterWalResponse> AlterWalAsync( AlterWalRequest request_,
                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        AlterWalResponse actualResponse_ = await SubmitRequestAsync<AlterWalResponse>("/alter/wal", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AlterWalResponse alterWal( IList<string> table_names,
                                      IDictionary<string, string> options = null )
    {
        return alterWal( new AlterWalRequest( table_names, options ) );
    }

    public async System.Threading.Tasks.Task<AlterWalResponse> AlterWalAsync( IList<string> table_names,
                                                                              IDictionary<string, string> options = null,
                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await AlterWalAsync( new AlterWalRequest( table_names, options ), cancellationToken );
    }

    public AppendRecordsResponse appendRecords( AppendRecordsRequest request_ )
    {
        AppendRecordsResponse actualResponse_ = SubmitRequest<AppendRecordsResponse>("/append/records", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<AppendRecordsResponse> AppendRecordsAsync( AppendRecordsRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        AppendRecordsResponse actualResponse_ = await SubmitRequestAsync<AppendRecordsResponse>("/append/records", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public AppendRecordsResponse appendRecords( string table_name,
                                                string source_table_name,
                                                IDictionary<string, string> field_map,
                                                IDictionary<string, string> options = null )
    {
        return appendRecords( new AppendRecordsRequest( table_name, source_table_name,
                                                        field_map, options ) );
    }

    public async System.Threading.Tasks.Task<AppendRecordsResponse> AppendRecordsAsync( string table_name,
                                                                                        string source_table_name,
                                                                                        IDictionary<string, string> field_map,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await AppendRecordsAsync( new AppendRecordsRequest( table_name,
                                                                   source_table_name,
                                                                   field_map, options ), cancellationToken );
    }

    public CheckTableResponse checkTable( CheckTableRequest request_ )
    {
        CheckTableResponse actualResponse_ = SubmitRequest<CheckTableResponse>("/check/table", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CheckTableResponse> CheckTableAsync( CheckTableRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        CheckTableResponse actualResponse_ = await SubmitRequestAsync<CheckTableResponse>("/check/table", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CheckTableResponse checkTable( IList<string> table_names,
                                          IDictionary<string, string> options = null )
    {
        return checkTable( new CheckTableRequest( table_names, options ) );
    }

    public async System.Threading.Tasks.Task<CheckTableResponse> CheckTableAsync( IList<string> table_names,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await CheckTableAsync( new CheckTableRequest( table_names, options ), cancellationToken );
    }

    public ClearStatisticsResponse clearStatistics( ClearStatisticsRequest request_ )
    {
        ClearStatisticsResponse actualResponse_ = SubmitRequest<ClearStatisticsResponse>("/clear/statistics", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ClearStatisticsResponse> ClearStatisticsAsync( ClearStatisticsRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        ClearStatisticsResponse actualResponse_ = await SubmitRequestAsync<ClearStatisticsResponse>("/clear/statistics", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ClearStatisticsResponse clearStatistics( string table_name = "",
                                                    string column_name = "",
                                                    IDictionary<string, string> options = null )
    {
        return clearStatistics( new ClearStatisticsRequest( table_name, column_name,
                                                            options ) );
    }

    public async System.Threading.Tasks.Task<ClearStatisticsResponse> ClearStatisticsAsync( string table_name = "",
                                                                                            string column_name = "",
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await ClearStatisticsAsync( new ClearStatisticsRequest( table_name,
                                                                       column_name,
                                                                       options ), cancellationToken );
    }

    public ClearTableResponse clearTable( ClearTableRequest request_ )
    {
        ClearTableResponse actualResponse_ = SubmitRequest<ClearTableResponse>("/clear/table", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ClearTableResponse> ClearTableAsync( ClearTableRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        ClearTableResponse actualResponse_ = await SubmitRequestAsync<ClearTableResponse>("/clear/table", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ClearTableResponse clearTable( string table_name = "",
                                          string authorization = "",
                                          IDictionary<string, string> options = null )
    {
        return clearTable( new ClearTableRequest( table_name, authorization, options ) );
    }

    public async System.Threading.Tasks.Task<ClearTableResponse> ClearTableAsync( string table_name = "",
                                                                                  string authorization = "",
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await ClearTableAsync( new ClearTableRequest( table_name, authorization,
                                                             options ), cancellationToken );
    }

    public ClearTableMonitorResponse clearTableMonitor( ClearTableMonitorRequest request_ )
    {
        ClearTableMonitorResponse actualResponse_ = SubmitRequest<ClearTableMonitorResponse>("/clear/tablemonitor", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ClearTableMonitorResponse> ClearTableMonitorAsync( ClearTableMonitorRequest request_,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        ClearTableMonitorResponse actualResponse_ = await SubmitRequestAsync<ClearTableMonitorResponse>("/clear/tablemonitor", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ClearTableMonitorResponse clearTableMonitor( string topic_id,
                                                        IDictionary<string, string> options = null )
    {
        return clearTableMonitor( new ClearTableMonitorRequest( topic_id, options ) );
    }

    public async System.Threading.Tasks.Task<ClearTableMonitorResponse> ClearTableMonitorAsync( string topic_id,
                                                                                                IDictionary<string, string> options = null,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await ClearTableMonitorAsync( new ClearTableMonitorRequest( topic_id,
                                                                           options ), cancellationToken );
    }

    public ClearTablesResponse clearTables( ClearTablesRequest request_ )
    {
        ClearTablesResponse actualResponse_ = SubmitRequest<ClearTablesResponse>("/clear/tables", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ClearTablesResponse> ClearTablesAsync( ClearTablesRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        ClearTablesResponse actualResponse_ = await SubmitRequestAsync<ClearTablesResponse>("/clear/tables", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ClearTablesResponse clearTables( IList<string> table_names = null,
                                            IDictionary<string, string> options = null )
    {
        return clearTables( new ClearTablesRequest( table_names, options ) );
    }

    public async System.Threading.Tasks.Task<ClearTablesResponse> ClearTablesAsync( IList<string> table_names = null,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await ClearTablesAsync( new ClearTablesRequest( table_names, options ), cancellationToken );
    }

    public ClearTriggerResponse clearTrigger( ClearTriggerRequest request_ )
    {
        ClearTriggerResponse actualResponse_ = SubmitRequest<ClearTriggerResponse>("/clear/trigger", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ClearTriggerResponse> ClearTriggerAsync( ClearTriggerRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        ClearTriggerResponse actualResponse_ = await SubmitRequestAsync<ClearTriggerResponse>("/clear/trigger", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ClearTriggerResponse clearTrigger( string trigger_id,
                                              IDictionary<string, string> options = null )
    {
        return clearTrigger( new ClearTriggerRequest( trigger_id, options ) );
    }

    public async System.Threading.Tasks.Task<ClearTriggerResponse> ClearTriggerAsync( string trigger_id,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await ClearTriggerAsync( new ClearTriggerRequest( trigger_id, options ), cancellationToken );
    }

    public CollectStatisticsResponse collectStatistics( CollectStatisticsRequest request_ )
    {
        CollectStatisticsResponse actualResponse_ = SubmitRequest<CollectStatisticsResponse>("/collect/statistics", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CollectStatisticsResponse> CollectStatisticsAsync( CollectStatisticsRequest request_,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        CollectStatisticsResponse actualResponse_ = await SubmitRequestAsync<CollectStatisticsResponse>("/collect/statistics", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CollectStatisticsResponse collectStatistics( string table_name,
                                                        IList<string> column_names,
                                                        IDictionary<string, string> options = null )
    {
        return collectStatistics( new CollectStatisticsRequest( table_name, column_names,
                                                                options ) );
    }

    public async System.Threading.Tasks.Task<CollectStatisticsResponse> CollectStatisticsAsync( string table_name,
                                                                                                IList<string> column_names,
                                                                                                IDictionary<string, string> options = null,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await CollectStatisticsAsync( new CollectStatisticsRequest( table_name,
                                                                           column_names,
                                                                           options ), cancellationToken );
    }

    public CreateBackupResponse createBackup( CreateBackupRequest request_ )
    {
        CreateBackupResponse actualResponse_ = SubmitRequest<CreateBackupResponse>("/create/backup", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateBackupResponse> CreateBackupAsync( CreateBackupRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        CreateBackupResponse actualResponse_ = await SubmitRequestAsync<CreateBackupResponse>("/create/backup", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateBackupResponse createBackup( string backup_name,
                                              string backup_type,
                                              IDictionary<string, string> backup_objects_map,
                                              string datasink_name,
                                              IDictionary<string, string> options = null )
    {
        return createBackup( new CreateBackupRequest( backup_name, backup_type,
                                                      backup_objects_map, datasink_name,
                                                      options ) );
    }

    public async System.Threading.Tasks.Task<CreateBackupResponse> CreateBackupAsync( string backup_name,
                                                                                      string backup_type,
                                                                                      IDictionary<string, string> backup_objects_map,
                                                                                      string datasink_name,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateBackupAsync( new CreateBackupRequest( backup_name, backup_type,
                                                                 backup_objects_map,
                                                                 datasink_name, options ), cancellationToken );
    }

    public CreateCatalogResponse createCatalog( CreateCatalogRequest request_ )
    {
        CreateCatalogResponse actualResponse_ = SubmitRequest<CreateCatalogResponse>("/create/catalog", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateCatalogResponse> CreateCatalogAsync( CreateCatalogRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        CreateCatalogResponse actualResponse_ = await SubmitRequestAsync<CreateCatalogResponse>("/create/catalog", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateCatalogResponse createCatalog( string name,
                                                string table_format,
                                                string location,
                                                string type,
                                                string credential,
                                                string datasource,
                                                IDictionary<string, string> options = null )
    {
        return createCatalog( new CreateCatalogRequest( name, table_format, location,
                                                        type, credential, datasource,
                                                        options ) );
    }

    public async System.Threading.Tasks.Task<CreateCatalogResponse> CreateCatalogAsync( string name,
                                                                                        string table_format,
                                                                                        string location,
                                                                                        string type,
                                                                                        string credential,
                                                                                        string datasource,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateCatalogAsync( new CreateCatalogRequest( name, table_format,
                                                                   location, type,
                                                                   credential, datasource,
                                                                   options ), cancellationToken );
    }

    public CreateContainerRegistryResponse createContainerRegistry( CreateContainerRegistryRequest request_ )
    {
        CreateContainerRegistryResponse actualResponse_ = SubmitRequest<CreateContainerRegistryResponse>("/create/container/registry", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateContainerRegistryResponse> CreateContainerRegistryAsync( CreateContainerRegistryRequest request_,
                                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        CreateContainerRegistryResponse actualResponse_ = await SubmitRequestAsync<CreateContainerRegistryResponse>("/create/container/registry", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateContainerRegistryResponse createContainerRegistry( string registry_name,
                                                                    string uri,
                                                                    string credential,
                                                                    IDictionary<string, string> options = null )
    {
        return createContainerRegistry( new CreateContainerRegistryRequest( registry_name,
                                                                            uri,
                                                                            credential,
                                                                            options ) );
    }

    public async System.Threading.Tasks.Task<CreateContainerRegistryResponse> CreateContainerRegistryAsync( string registry_name,
                                                                                                            string uri,
                                                                                                            string credential,
                                                                                                            IDictionary<string, string> options = null,
                                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateContainerRegistryAsync( new CreateContainerRegistryRequest( registry_name,
                                                                                       uri,
                                                                                       credential,
                                                                                       options ), cancellationToken );
    }

    public CreateCredentialResponse createCredential( CreateCredentialRequest request_ )
    {
        CreateCredentialResponse actualResponse_ = SubmitRequest<CreateCredentialResponse>("/create/credential", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateCredentialResponse> CreateCredentialAsync( CreateCredentialRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        CreateCredentialResponse actualResponse_ = await SubmitRequestAsync<CreateCredentialResponse>("/create/credential", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateCredentialResponse createCredential( string credential_name,
                                                      string type,
                                                      string identity,
                                                      string secret,
                                                      IDictionary<string, string> options = null )
    {
        return createCredential( new CreateCredentialRequest( credential_name, type,
                                                              identity, secret, options ) );
    }

    public async System.Threading.Tasks.Task<CreateCredentialResponse> CreateCredentialAsync( string credential_name,
                                                                                              string type,
                                                                                              string identity,
                                                                                              string secret,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateCredentialAsync( new CreateCredentialRequest( credential_name,
                                                                         type, identity,
                                                                         secret, options ), cancellationToken );
    }

    public CreateDatasinkResponse createDatasink( CreateDatasinkRequest request_ )
    {
        CreateDatasinkResponse actualResponse_ = SubmitRequest<CreateDatasinkResponse>("/create/datasink", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateDatasinkResponse> CreateDatasinkAsync( CreateDatasinkRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        CreateDatasinkResponse actualResponse_ = await SubmitRequestAsync<CreateDatasinkResponse>("/create/datasink", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateDatasinkResponse createDatasink( string name,
                                                  string destination,
                                                  IDictionary<string, string> options = null )
    {
        return createDatasink( new CreateDatasinkRequest( name, destination, options ) );
    }

    public async System.Threading.Tasks.Task<CreateDatasinkResponse> CreateDatasinkAsync( string name,
                                                                                          string destination,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateDatasinkAsync( new CreateDatasinkRequest( name, destination,
                                                                     options ), cancellationToken );
    }

    public CreateDatasourceResponse createDatasource( CreateDatasourceRequest request_ )
    {
        CreateDatasourceResponse actualResponse_ = SubmitRequest<CreateDatasourceResponse>("/create/datasource", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateDatasourceResponse> CreateDatasourceAsync( CreateDatasourceRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        CreateDatasourceResponse actualResponse_ = await SubmitRequestAsync<CreateDatasourceResponse>("/create/datasource", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateDatasourceResponse createDatasource( string name,
                                                      string location,
                                                      string user_name,
                                                      string password,
                                                      IDictionary<string, string> options = null )
    {
        return createDatasource( new CreateDatasourceRequest( name, location, user_name,
                                                              password, options ) );
    }

    public async System.Threading.Tasks.Task<CreateDatasourceResponse> CreateDatasourceAsync( string name,
                                                                                              string location,
                                                                                              string user_name,
                                                                                              string password,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateDatasourceAsync( new CreateDatasourceRequest( name, location,
                                                                         user_name,
                                                                         password, options ), cancellationToken );
    }

    public CreateDeltaTableResponse createDeltaTable( CreateDeltaTableRequest request_ )
    {
        CreateDeltaTableResponse actualResponse_ = SubmitRequest<CreateDeltaTableResponse>("/create/deltatable", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateDeltaTableResponse> CreateDeltaTableAsync( CreateDeltaTableRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        CreateDeltaTableResponse actualResponse_ = await SubmitRequestAsync<CreateDeltaTableResponse>("/create/deltatable", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateDeltaTableResponse createDeltaTable( string delta_table_name,
                                                      string table_name,
                                                      IDictionary<string, string> options = null )
    {
        return createDeltaTable( new CreateDeltaTableRequest( delta_table_name,
                                                              table_name, options ) );
    }

    public async System.Threading.Tasks.Task<CreateDeltaTableResponse> CreateDeltaTableAsync( string delta_table_name,
                                                                                              string table_name,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateDeltaTableAsync( new CreateDeltaTableRequest( delta_table_name,
                                                                         table_name,
                                                                         options ), cancellationToken );
    }

    public CreateDirectoryResponse createDirectory( CreateDirectoryRequest request_ )
    {
        CreateDirectoryResponse actualResponse_ = SubmitRequest<CreateDirectoryResponse>("/create/directory", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateDirectoryResponse> CreateDirectoryAsync( CreateDirectoryRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        CreateDirectoryResponse actualResponse_ = await SubmitRequestAsync<CreateDirectoryResponse>("/create/directory", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateDirectoryResponse createDirectory( string directory_name,
                                                    IDictionary<string, string> options = null )
    {
        return createDirectory( new CreateDirectoryRequest( directory_name, options ) );
    }

    public async System.Threading.Tasks.Task<CreateDirectoryResponse> CreateDirectoryAsync( string directory_name,
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateDirectoryAsync( new CreateDirectoryRequest( directory_name,
                                                                       options ), cancellationToken );
    }

    public CreateEnvironmentResponse createEnvironment( CreateEnvironmentRequest request_ )
    {
        CreateEnvironmentResponse actualResponse_ = SubmitRequest<CreateEnvironmentResponse>("/create/environment", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateEnvironmentResponse> CreateEnvironmentAsync( CreateEnvironmentRequest request_,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        CreateEnvironmentResponse actualResponse_ = await SubmitRequestAsync<CreateEnvironmentResponse>("/create/environment", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateEnvironmentResponse createEnvironment( string environment_name,
                                                        IDictionary<string, string> options = null )
    {
        return createEnvironment( new CreateEnvironmentRequest( environment_name, options ) );
    }

    public async System.Threading.Tasks.Task<CreateEnvironmentResponse> CreateEnvironmentAsync( string environment_name,
                                                                                                IDictionary<string, string> options = null,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateEnvironmentAsync( new CreateEnvironmentRequest( environment_name,
                                                                           options ), cancellationToken );
    }

    public CreateGraphResponse createGraph( CreateGraphRequest request_ )
    {
        CreateGraphResponse actualResponse_ = SubmitRequest<CreateGraphResponse>("/create/graph", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateGraphResponse> CreateGraphAsync( CreateGraphRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        CreateGraphResponse actualResponse_ = await SubmitRequestAsync<CreateGraphResponse>("/create/graph", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateGraphResponse createGraph( string graph_name,
                                            bool directed_graph,
                                            IList<string> nodes,
                                            IList<string> edges,
                                            IList<string> weights,
                                            IList<string> restrictions,
                                            IDictionary<string, string> options = null )
    {
        return createGraph( new CreateGraphRequest( graph_name, directed_graph, nodes,
                                                    edges, weights, restrictions, options ) );
    }

    public async System.Threading.Tasks.Task<CreateGraphResponse> CreateGraphAsync( string graph_name,
                                                                                    bool directed_graph,
                                                                                    IList<string> nodes,
                                                                                    IList<string> edges,
                                                                                    IList<string> weights,
                                                                                    IList<string> restrictions,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateGraphAsync( new CreateGraphRequest( graph_name, directed_graph,
                                                               nodes, edges, weights,
                                                               restrictions, options ), cancellationToken );
    }

    public CreateJobResponse createJob( CreateJobRequest request_ )
    {
        CreateJobResponse actualResponse_ = SubmitRequest<CreateJobResponse>("/create/job", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateJobResponse> CreateJobAsync( CreateJobRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        CreateJobResponse actualResponse_ = await SubmitRequestAsync<CreateJobResponse>("/create/job", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateJobResponse createJob( string endpoint,
                                        string request_encoding,
                                        byte[] data,
                                        string data_str,
                                        IDictionary<string, string> options = null )
    {
        return createJob( new CreateJobRequest( endpoint, request_encoding, data,
                                                data_str, options ) );
    }

    public async System.Threading.Tasks.Task<CreateJobResponse> CreateJobAsync( string endpoint,
                                                                                string request_encoding,
                                                                                byte[] data,
                                                                                string data_str,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateJobAsync( new CreateJobRequest( endpoint, request_encoding,
                                                           data, data_str, options ), cancellationToken );
    }

    public CreateJoinTableResponse createJoinTable( CreateJoinTableRequest request_ )
    {
        CreateJoinTableResponse actualResponse_ = SubmitRequest<CreateJoinTableResponse>("/create/jointable", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateJoinTableResponse> CreateJoinTableAsync( CreateJoinTableRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        CreateJoinTableResponse actualResponse_ = await SubmitRequestAsync<CreateJoinTableResponse>("/create/jointable", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateJoinTableResponse createJoinTable( string join_table_name,
                                                    IList<string> table_names,
                                                    IList<string> column_names,
                                                    IList<string> expressions = null,
                                                    IDictionary<string, string> options = null )
    {
        return createJoinTable( new CreateJoinTableRequest( join_table_name, table_names,
                                                            column_names, expressions,
                                                            options ) );
    }

    public async System.Threading.Tasks.Task<CreateJoinTableResponse> CreateJoinTableAsync( string join_table_name,
                                                                                            IList<string> table_names,
                                                                                            IList<string> column_names,
                                                                                            IList<string> expressions = null,
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateJoinTableAsync( new CreateJoinTableRequest( join_table_name,
                                                                       table_names,
                                                                       column_names,
                                                                       expressions,
                                                                       options ), cancellationToken );
    }

    public CreateMaterializedViewResponse createMaterializedView( CreateMaterializedViewRequest request_ )
    {
        CreateMaterializedViewResponse actualResponse_ = SubmitRequest<CreateMaterializedViewResponse>("/create/materializedview", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateMaterializedViewResponse> CreateMaterializedViewAsync( CreateMaterializedViewRequest request_,
                                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        CreateMaterializedViewResponse actualResponse_ = await SubmitRequestAsync<CreateMaterializedViewResponse>("/create/materializedview", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateMaterializedViewResponse createMaterializedView( string table_name,
                                                                  IDictionary<string, string> options = null )
    {
        return createMaterializedView( new CreateMaterializedViewRequest( table_name,
                                                                          options ) );
    }

    public async System.Threading.Tasks.Task<CreateMaterializedViewResponse> CreateMaterializedViewAsync( string table_name,
                                                                                                          IDictionary<string, string> options = null,
                                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateMaterializedViewAsync( new CreateMaterializedViewRequest( table_name,
                                                                                     options ), cancellationToken );
    }

    public CreateProcResponse createProc( CreateProcRequest request_ )
    {
        CreateProcResponse actualResponse_ = SubmitRequest<CreateProcResponse>("/create/proc", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateProcResponse> CreateProcAsync( CreateProcRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        CreateProcResponse actualResponse_ = await SubmitRequestAsync<CreateProcResponse>("/create/proc", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateProcResponse createProc( string proc_name,
                                          string execution_mode = CreateProcRequest.ExecutionMode.DISTRIBUTED,
                                          IDictionary<string, byte[]> files = null,
                                          string command = "",
                                          IList<string> args = null,
                                          IDictionary<string, string> options = null )
    {
        return createProc( new CreateProcRequest( proc_name, execution_mode, files,
                                                  command, args, options ) );
    }

    public async System.Threading.Tasks.Task<CreateProcResponse> CreateProcAsync( string proc_name,
                                                                                  string execution_mode = CreateProcRequest.ExecutionMode.DISTRIBUTED,
                                                                                  IDictionary<string, byte[]> files = null,
                                                                                  string command = "",
                                                                                  IList<string> args = null,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateProcAsync( new CreateProcRequest( proc_name, execution_mode,
                                                             files, command, args, options ), cancellationToken );
    }

    public CreateProjectionResponse createProjection( CreateProjectionRequest request_ )
    {
        CreateProjectionResponse actualResponse_ = SubmitRequest<CreateProjectionResponse>("/create/projection", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateProjectionResponse> CreateProjectionAsync( CreateProjectionRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        CreateProjectionResponse actualResponse_ = await SubmitRequestAsync<CreateProjectionResponse>("/create/projection", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateProjectionResponse createProjection( string table_name,
                                                      string projection_name,
                                                      IList<string> column_names,
                                                      IDictionary<string, string> options = null )
    {
        return createProjection( new CreateProjectionRequest( table_name, projection_name,
                                                              column_names, options ) );
    }

    public async System.Threading.Tasks.Task<CreateProjectionResponse> CreateProjectionAsync( string table_name,
                                                                                              string projection_name,
                                                                                              IList<string> column_names,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateProjectionAsync( new CreateProjectionRequest( table_name,
                                                                         projection_name,
                                                                         column_names,
                                                                         options ), cancellationToken );
    }

    public CreateResourceGroupResponse createResourceGroup( CreateResourceGroupRequest request_ )
    {
        CreateResourceGroupResponse actualResponse_ = SubmitRequest<CreateResourceGroupResponse>("/create/resourcegroup", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateResourceGroupResponse> CreateResourceGroupAsync( CreateResourceGroupRequest request_,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        CreateResourceGroupResponse actualResponse_ = await SubmitRequestAsync<CreateResourceGroupResponse>("/create/resourcegroup", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateResourceGroupResponse createResourceGroup( string name,
                                                            IDictionary<string, IDictionary<string, string>> tier_attributes,
                                                            string ranking,
                                                            string adjoining_resource_group = "",
                                                            IDictionary<string, string> options = null )
    {
        return createResourceGroup( new CreateResourceGroupRequest( name, tier_attributes,
                                                                    ranking,
                                                                    adjoining_resource_group,
                                                                    options ) );
    }

    public async System.Threading.Tasks.Task<CreateResourceGroupResponse> CreateResourceGroupAsync( string name,
                                                                                                    IDictionary<string, IDictionary<string, string>> tier_attributes,
                                                                                                    string ranking,
                                                                                                    string adjoining_resource_group = "",
                                                                                                    IDictionary<string, string> options = null,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateResourceGroupAsync( new CreateResourceGroupRequest( name,
                                                                               tier_attributes,
                                                                               ranking,
                                                                               adjoining_resource_group,
                                                                               options ), cancellationToken );
    }

    public CreateRoleResponse createRole( CreateRoleRequest request_ )
    {
        CreateRoleResponse actualResponse_ = SubmitRequest<CreateRoleResponse>("/create/role", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateRoleResponse> CreateRoleAsync( CreateRoleRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        CreateRoleResponse actualResponse_ = await SubmitRequestAsync<CreateRoleResponse>("/create/role", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateRoleResponse createRole( string name,
                                          IDictionary<string, string> options = null )
    {
        return createRole( new CreateRoleRequest( name, options ) );
    }

    public async System.Threading.Tasks.Task<CreateRoleResponse> CreateRoleAsync( string name,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateRoleAsync( new CreateRoleRequest( name, options ), cancellationToken );
    }

    public CreateSchemaResponse createSchema( CreateSchemaRequest request_ )
    {
        CreateSchemaResponse actualResponse_ = SubmitRequest<CreateSchemaResponse>("/create/schema", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateSchemaResponse> CreateSchemaAsync( CreateSchemaRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        CreateSchemaResponse actualResponse_ = await SubmitRequestAsync<CreateSchemaResponse>("/create/schema", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateSchemaResponse createSchema( string schema_name,
                                              IDictionary<string, string> options = null )
    {
        return createSchema( new CreateSchemaRequest( schema_name, options ) );
    }

    public async System.Threading.Tasks.Task<CreateSchemaResponse> CreateSchemaAsync( string schema_name,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateSchemaAsync( new CreateSchemaRequest( schema_name, options ), cancellationToken );
    }

    public CreateStateTableResponse createStateTable( CreateStateTableRequest request_ )
    {
        CreateStateTableResponse actualResponse_ = SubmitRequest<CreateStateTableResponse>("/create/statetable", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateStateTableResponse> CreateStateTableAsync( CreateStateTableRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        CreateStateTableResponse actualResponse_ = await SubmitRequestAsync<CreateStateTableResponse>("/create/statetable", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateStateTableResponse createStateTable( string table_name,
                                                      string input_table_name,
                                                      string init_table_name,
                                                      IDictionary<string, string> options = null )
    {
        return createStateTable( new CreateStateTableRequest( table_name,
                                                              input_table_name,
                                                              init_table_name, options ) );
    }

    public async System.Threading.Tasks.Task<CreateStateTableResponse> CreateStateTableAsync( string table_name,
                                                                                              string input_table_name,
                                                                                              string init_table_name,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateStateTableAsync( new CreateStateTableRequest( table_name,
                                                                         input_table_name,
                                                                         init_table_name,
                                                                         options ), cancellationToken );
    }

    public CreateTableResponse createTable( CreateTableRequest request_ )
    {
        CreateTableResponse actualResponse_ = SubmitRequest<CreateTableResponse>("/create/table", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateTableResponse> CreateTableAsync( CreateTableRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        CreateTableResponse actualResponse_ = await SubmitRequestAsync<CreateTableResponse>("/create/table", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateTableResponse createTable( string table_name,
                                            string type_id,
                                            IDictionary<string, string> options = null )
    {
        return createTable( new CreateTableRequest( table_name, type_id, options ) );
    }

    public async System.Threading.Tasks.Task<CreateTableResponse> CreateTableAsync( string table_name,
                                                                                    string type_id,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateTableAsync( new CreateTableRequest( table_name, type_id,
                                                               options ), cancellationToken );
    }

    public CreateTableExternalResponse createTableExternal( CreateTableExternalRequest request_ )
    {
        CreateTableExternalResponse actualResponse_ = SubmitRequest<CreateTableExternalResponse>("/create/table/external", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateTableExternalResponse> CreateTableExternalAsync( CreateTableExternalRequest request_,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        CreateTableExternalResponse actualResponse_ = await SubmitRequestAsync<CreateTableExternalResponse>("/create/table/external", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateTableExternalResponse createTableExternal( string table_name,
                                                            IList<string> filepaths,
                                                            IDictionary<string, IDictionary<string, string>> modify_columns = null,
                                                            IDictionary<string, string> create_table_options = null,
                                                            IDictionary<string, string> options = null )
    {
        return createTableExternal( new CreateTableExternalRequest( table_name, filepaths,
                                                                    modify_columns,
                                                                    create_table_options,
                                                                    options ) );
    }

    public async System.Threading.Tasks.Task<CreateTableExternalResponse> CreateTableExternalAsync( string table_name,
                                                                                                    IList<string> filepaths,
                                                                                                    IDictionary<string, IDictionary<string, string>> modify_columns = null,
                                                                                                    IDictionary<string, string> create_table_options = null,
                                                                                                    IDictionary<string, string> options = null,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateTableExternalAsync( new CreateTableExternalRequest( table_name,
                                                                               filepaths,
                                                                               modify_columns,
                                                                               create_table_options,
                                                                               options ), cancellationToken );
    }

    public CreateTableMonitorResponse createTableMonitor( CreateTableMonitorRequest request_ )
    {
        CreateTableMonitorResponse actualResponse_ = SubmitRequest<CreateTableMonitorResponse>("/create/tablemonitor", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateTableMonitorResponse> CreateTableMonitorAsync( CreateTableMonitorRequest request_,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        CreateTableMonitorResponse actualResponse_ = await SubmitRequestAsync<CreateTableMonitorResponse>("/create/tablemonitor", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateTableMonitorResponse createTableMonitor( string table_name,
                                                          IDictionary<string, string> options = null )
    {
        return createTableMonitor( new CreateTableMonitorRequest( table_name, options ) );
    }

    public async System.Threading.Tasks.Task<CreateTableMonitorResponse> CreateTableMonitorAsync( string table_name,
                                                                                                  IDictionary<string, string> options = null,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateTableMonitorAsync( new CreateTableMonitorRequest( table_name,
                                                                             options ), cancellationToken );
    }

    public CreateTriggerByAreaResponse createTriggerByArea( CreateTriggerByAreaRequest request_ )
    {
        CreateTriggerByAreaResponse actualResponse_ = SubmitRequest<CreateTriggerByAreaResponse>("/create/trigger/byarea", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateTriggerByAreaResponse> CreateTriggerByAreaAsync( CreateTriggerByAreaRequest request_,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        CreateTriggerByAreaResponse actualResponse_ = await SubmitRequestAsync<CreateTriggerByAreaResponse>("/create/trigger/byarea", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateTriggerByAreaResponse createTriggerByArea( string request_id,
                                                            IList<string> table_names,
                                                            string x_column_name,
                                                            IList<double> x_vector,
                                                            string y_column_name,
                                                            IList<double> y_vector,
                                                            IDictionary<string, string> options = null )
    {
        return createTriggerByArea( new CreateTriggerByAreaRequest( request_id,
                                                                    table_names,
                                                                    x_column_name,
                                                                    x_vector,
                                                                    y_column_name,
                                                                    y_vector, options ) );
    }

    public async System.Threading.Tasks.Task<CreateTriggerByAreaResponse> CreateTriggerByAreaAsync( string request_id,
                                                                                                    IList<string> table_names,
                                                                                                    string x_column_name,
                                                                                                    IList<double> x_vector,
                                                                                                    string y_column_name,
                                                                                                    IList<double> y_vector,
                                                                                                    IDictionary<string, string> options = null,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateTriggerByAreaAsync( new CreateTriggerByAreaRequest( request_id,
                                                                               table_names,
                                                                               x_column_name,
                                                                               x_vector,
                                                                               y_column_name,
                                                                               y_vector,
                                                                               options ), cancellationToken );
    }

    public CreateTriggerByRangeResponse createTriggerByRange( CreateTriggerByRangeRequest request_ )
    {
        CreateTriggerByRangeResponse actualResponse_ = SubmitRequest<CreateTriggerByRangeResponse>("/create/trigger/byrange", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateTriggerByRangeResponse> CreateTriggerByRangeAsync( CreateTriggerByRangeRequest request_,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        CreateTriggerByRangeResponse actualResponse_ = await SubmitRequestAsync<CreateTriggerByRangeResponse>("/create/trigger/byrange", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateTriggerByRangeResponse createTriggerByRange( string request_id,
                                                              IList<string> table_names,
                                                              string column_name,
                                                              double min,
                                                              double max,
                                                              IDictionary<string, string> options = null )
    {
        return createTriggerByRange( new CreateTriggerByRangeRequest( request_id,
                                                                      table_names,
                                                                      column_name, min,
                                                                      max, options ) );
    }

    public async System.Threading.Tasks.Task<CreateTriggerByRangeResponse> CreateTriggerByRangeAsync( string request_id,
                                                                                                      IList<string> table_names,
                                                                                                      string column_name,
                                                                                                      double min,
                                                                                                      double max,
                                                                                                      IDictionary<string, string> options = null,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateTriggerByRangeAsync( new CreateTriggerByRangeRequest( request_id,
                                                                                 table_names,
                                                                                 column_name,
                                                                                 min, max,
                                                                                 options ), cancellationToken );
    }

    public CreateTypeResponse createType( CreateTypeRequest request_ )
    {
        CreateTypeResponse actualResponse_ = SubmitRequest<CreateTypeResponse>("/create/type", request_, false);

        SetDecoderIfMissing( actualResponse_.type_id,
                             actualResponse_.label,
                             actualResponse_.type_definition,
                             actualResponse_.properties );
        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateTypeResponse> CreateTypeAsync( CreateTypeRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        CreateTypeResponse actualResponse_ = await SubmitRequestAsync<CreateTypeResponse>("/create/type", request_, false, true, cancellationToken);

        SetDecoderIfMissing( actualResponse_.type_id,
                             actualResponse_.label,
                             actualResponse_.type_definition,
                             actualResponse_.properties );
        return actualResponse_;
    }

    public CreateTypeResponse createType( string type_definition,
                                          string label,
                                          IDictionary<string, IList<string>> properties = null,
                                          IDictionary<string, string> options = null )
    {
        return createType( new CreateTypeRequest( type_definition, label, properties,
                                                  options ) );
    }

    public async System.Threading.Tasks.Task<CreateTypeResponse> CreateTypeAsync( string type_definition,
                                                                                  string label,
                                                                                  IDictionary<string, IList<string>> properties = null,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateTypeAsync( new CreateTypeRequest( type_definition, label,
                                                             properties, options ), cancellationToken );
    }

    public CreateUnionResponse createUnion( CreateUnionRequest request_ )
    {
        CreateUnionResponse actualResponse_ = SubmitRequest<CreateUnionResponse>("/create/union", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateUnionResponse> CreateUnionAsync( CreateUnionRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        CreateUnionResponse actualResponse_ = await SubmitRequestAsync<CreateUnionResponse>("/create/union", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateUnionResponse createUnion( string table_name,
                                            IList<string> table_names,
                                            IList<IList<string>> input_column_names,
                                            IList<string> output_column_names,
                                            IDictionary<string, string> options = null )
    {
        return createUnion( new CreateUnionRequest( table_name, table_names,
                                                    input_column_names,
                                                    output_column_names, options ) );
    }

    public async System.Threading.Tasks.Task<CreateUnionResponse> CreateUnionAsync( string table_name,
                                                                                    IList<string> table_names,
                                                                                    IList<IList<string>> input_column_names,
                                                                                    IList<string> output_column_names,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateUnionAsync( new CreateUnionRequest( table_name, table_names,
                                                               input_column_names,
                                                               output_column_names,
                                                               options ), cancellationToken );
    }

    public CreateUserExternalResponse createUserExternal( CreateUserExternalRequest request_ )
    {
        CreateUserExternalResponse actualResponse_ = SubmitRequest<CreateUserExternalResponse>("/create/user/external", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateUserExternalResponse> CreateUserExternalAsync( CreateUserExternalRequest request_,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        CreateUserExternalResponse actualResponse_ = await SubmitRequestAsync<CreateUserExternalResponse>("/create/user/external", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateUserExternalResponse createUserExternal( string name,
                                                          IDictionary<string, string> options = null )
    {
        return createUserExternal( new CreateUserExternalRequest( name, options ) );
    }

    public async System.Threading.Tasks.Task<CreateUserExternalResponse> CreateUserExternalAsync( string name,
                                                                                                  IDictionary<string, string> options = null,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateUserExternalAsync( new CreateUserExternalRequest( name, options ), cancellationToken );
    }

    public CreateUserInternalResponse createUserInternal( CreateUserInternalRequest request_ )
    {
        CreateUserInternalResponse actualResponse_ = SubmitRequest<CreateUserInternalResponse>("/create/user/internal", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateUserInternalResponse> CreateUserInternalAsync( CreateUserInternalRequest request_,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        CreateUserInternalResponse actualResponse_ = await SubmitRequestAsync<CreateUserInternalResponse>("/create/user/internal", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateUserInternalResponse createUserInternal( string name,
                                                          string password,
                                                          IDictionary<string, string> options = null )
    {
        return createUserInternal( new CreateUserInternalRequest( name, password, options ) );
    }

    public async System.Threading.Tasks.Task<CreateUserInternalResponse> CreateUserInternalAsync( string name,
                                                                                                  string password,
                                                                                                  IDictionary<string, string> options = null,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateUserInternalAsync( new CreateUserInternalRequest( name,
                                                                             password,
                                                                             options ), cancellationToken );
    }

    public CreateVideoResponse createVideo( CreateVideoRequest request_ )
    {
        CreateVideoResponse actualResponse_ = SubmitRequest<CreateVideoResponse>("/create/video", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<CreateVideoResponse> CreateVideoAsync( CreateVideoRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        CreateVideoResponse actualResponse_ = await SubmitRequestAsync<CreateVideoResponse>("/create/video", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public CreateVideoResponse createVideo( string attribute,
                                            string begin,
                                            double duration_seconds,
                                            string end,
                                            double frames_per_second,
                                            string style,
                                            string path,
                                            string style_parameters,
                                            IDictionary<string, string> options = null )
    {
        return createVideo( new CreateVideoRequest( attribute, begin, duration_seconds,
                                                    end, frames_per_second, style, path,
                                                    style_parameters, options ) );
    }

    public async System.Threading.Tasks.Task<CreateVideoResponse> CreateVideoAsync( string attribute,
                                                                                    string begin,
                                                                                    double duration_seconds,
                                                                                    string end,
                                                                                    double frames_per_second,
                                                                                    string style,
                                                                                    string path,
                                                                                    string style_parameters,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await CreateVideoAsync( new CreateVideoRequest( attribute, begin,
                                                               duration_seconds, end,
                                                               frames_per_second, style,
                                                               path, style_parameters,
                                                               options ), cancellationToken );
    }

    public DeleteDirectoryResponse deleteDirectory( DeleteDirectoryRequest request_ )
    {
        DeleteDirectoryResponse actualResponse_ = SubmitRequest<DeleteDirectoryResponse>("/delete/directory", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DeleteDirectoryResponse> DeleteDirectoryAsync( DeleteDirectoryRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        DeleteDirectoryResponse actualResponse_ = await SubmitRequestAsync<DeleteDirectoryResponse>("/delete/directory", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DeleteDirectoryResponse deleteDirectory( string directory_name,
                                                    IDictionary<string, string> options = null )
    {
        return deleteDirectory( new DeleteDirectoryRequest( directory_name, options ) );
    }

    public async System.Threading.Tasks.Task<DeleteDirectoryResponse> DeleteDirectoryAsync( string directory_name,
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await DeleteDirectoryAsync( new DeleteDirectoryRequest( directory_name,
                                                                       options ), cancellationToken );
    }

    public DeleteFilesResponse deleteFiles( DeleteFilesRequest request_ )
    {
        DeleteFilesResponse actualResponse_ = SubmitRequest<DeleteFilesResponse>("/delete/files", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DeleteFilesResponse> DeleteFilesAsync( DeleteFilesRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        DeleteFilesResponse actualResponse_ = await SubmitRequestAsync<DeleteFilesResponse>("/delete/files", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DeleteFilesResponse deleteFiles( IList<string> file_names,
                                            IDictionary<string, string> options = null )
    {
        return deleteFiles( new DeleteFilesRequest( file_names, options ) );
    }

    public async System.Threading.Tasks.Task<DeleteFilesResponse> DeleteFilesAsync( IList<string> file_names,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await DeleteFilesAsync( new DeleteFilesRequest( file_names, options ), cancellationToken );
    }

    public DeleteGraphResponse deleteGraph( DeleteGraphRequest request_ )
    {
        DeleteGraphResponse actualResponse_ = SubmitRequest<DeleteGraphResponse>("/delete/graph", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DeleteGraphResponse> DeleteGraphAsync( DeleteGraphRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        DeleteGraphResponse actualResponse_ = await SubmitRequestAsync<DeleteGraphResponse>("/delete/graph", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DeleteGraphResponse deleteGraph( string graph_name,
                                            IDictionary<string, string> options = null )
    {
        return deleteGraph( new DeleteGraphRequest( graph_name, options ) );
    }

    public async System.Threading.Tasks.Task<DeleteGraphResponse> DeleteGraphAsync( string graph_name,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await DeleteGraphAsync( new DeleteGraphRequest( graph_name, options ), cancellationToken );
    }

    public DeleteProcResponse deleteProc( DeleteProcRequest request_ )
    {
        DeleteProcResponse actualResponse_ = SubmitRequest<DeleteProcResponse>("/delete/proc", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DeleteProcResponse> DeleteProcAsync( DeleteProcRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        DeleteProcResponse actualResponse_ = await SubmitRequestAsync<DeleteProcResponse>("/delete/proc", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DeleteProcResponse deleteProc( string proc_name,
                                          IDictionary<string, string> options = null )
    {
        return deleteProc( new DeleteProcRequest( proc_name, options ) );
    }

    public async System.Threading.Tasks.Task<DeleteProcResponse> DeleteProcAsync( string proc_name,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await DeleteProcAsync( new DeleteProcRequest( proc_name, options ), cancellationToken );
    }

    public DeleteRecordsResponse deleteRecords( DeleteRecordsRequest request_ )
    {
        DeleteRecordsResponse actualResponse_ = SubmitRequest<DeleteRecordsResponse>("/delete/records", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DeleteRecordsResponse> DeleteRecordsAsync( DeleteRecordsRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        DeleteRecordsResponse actualResponse_ = await SubmitRequestAsync<DeleteRecordsResponse>("/delete/records", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DeleteRecordsResponse deleteRecords( string table_name,
                                                IList<string> expressions,
                                                IDictionary<string, string> options = null )
    {
        return deleteRecords( new DeleteRecordsRequest( table_name, expressions, options ) );
    }

    public async System.Threading.Tasks.Task<DeleteRecordsResponse> DeleteRecordsAsync( string table_name,
                                                                                        IList<string> expressions,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await DeleteRecordsAsync( new DeleteRecordsRequest( table_name,
                                                                   expressions, options ), cancellationToken );
    }

    public DeleteResourceGroupResponse deleteResourceGroup( DeleteResourceGroupRequest request_ )
    {
        DeleteResourceGroupResponse actualResponse_ = SubmitRequest<DeleteResourceGroupResponse>("/delete/resourcegroup", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DeleteResourceGroupResponse> DeleteResourceGroupAsync( DeleteResourceGroupRequest request_,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        DeleteResourceGroupResponse actualResponse_ = await SubmitRequestAsync<DeleteResourceGroupResponse>("/delete/resourcegroup", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DeleteResourceGroupResponse deleteResourceGroup( string name,
                                                            IDictionary<string, string> options = null )
    {
        return deleteResourceGroup( new DeleteResourceGroupRequest( name, options ) );
    }

    public async System.Threading.Tasks.Task<DeleteResourceGroupResponse> DeleteResourceGroupAsync( string name,
                                                                                                    IDictionary<string, string> options = null,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await DeleteResourceGroupAsync( new DeleteResourceGroupRequest( name,
                                                                               options ), cancellationToken );
    }

    public DeleteRoleResponse deleteRole( DeleteRoleRequest request_ )
    {
        DeleteRoleResponse actualResponse_ = SubmitRequest<DeleteRoleResponse>("/delete/role", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DeleteRoleResponse> DeleteRoleAsync( DeleteRoleRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        DeleteRoleResponse actualResponse_ = await SubmitRequestAsync<DeleteRoleResponse>("/delete/role", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DeleteRoleResponse deleteRole( string name,
                                          IDictionary<string, string> options = null )
    {
        return deleteRole( new DeleteRoleRequest( name, options ) );
    }

    public async System.Threading.Tasks.Task<DeleteRoleResponse> DeleteRoleAsync( string name,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await DeleteRoleAsync( new DeleteRoleRequest( name, options ), cancellationToken );
    }

    public DeleteUserResponse deleteUser( DeleteUserRequest request_ )
    {
        DeleteUserResponse actualResponse_ = SubmitRequest<DeleteUserResponse>("/delete/user", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DeleteUserResponse> DeleteUserAsync( DeleteUserRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        DeleteUserResponse actualResponse_ = await SubmitRequestAsync<DeleteUserResponse>("/delete/user", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DeleteUserResponse deleteUser( string name,
                                          IDictionary<string, string> options = null )
    {
        return deleteUser( new DeleteUserRequest( name, options ) );
    }

    public async System.Threading.Tasks.Task<DeleteUserResponse> DeleteUserAsync( string name,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await DeleteUserAsync( new DeleteUserRequest( name, options ), cancellationToken );
    }

    public DownloadFilesResponse downloadFiles( DownloadFilesRequest request_ )
    {
        DownloadFilesResponse actualResponse_ = SubmitRequest<DownloadFilesResponse>("/download/files", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DownloadFilesResponse> DownloadFilesAsync( DownloadFilesRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        DownloadFilesResponse actualResponse_ = await SubmitRequestAsync<DownloadFilesResponse>("/download/files", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DownloadFilesResponse downloadFiles( IList<string> file_names,
                                                IList<long> read_offsets,
                                                IList<long> read_lengths,
                                                IDictionary<string, string> options = null )
    {
        return downloadFiles( new DownloadFilesRequest( file_names, read_offsets,
                                                        read_lengths, options ) );
    }

    public async System.Threading.Tasks.Task<DownloadFilesResponse> DownloadFilesAsync( IList<string> file_names,
                                                                                        IList<long> read_offsets,
                                                                                        IList<long> read_lengths,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await DownloadFilesAsync( new DownloadFilesRequest( file_names,
                                                                   read_offsets,
                                                                   read_lengths, options ), cancellationToken );
    }

    public DropBackupResponse dropBackup( DropBackupRequest request_ )
    {
        DropBackupResponse actualResponse_ = SubmitRequest<DropBackupResponse>("/drop/backup", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DropBackupResponse> DropBackupAsync( DropBackupRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        DropBackupResponse actualResponse_ = await SubmitRequestAsync<DropBackupResponse>("/drop/backup", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DropBackupResponse dropBackup( string backup_name,
                                          string datasink_name,
                                          IDictionary<string, string> options = null )
    {
        return dropBackup( new DropBackupRequest( backup_name, datasink_name, options ) );
    }

    public async System.Threading.Tasks.Task<DropBackupResponse> DropBackupAsync( string backup_name,
                                                                                  string datasink_name,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await DropBackupAsync( new DropBackupRequest( backup_name, datasink_name,
                                                             options ), cancellationToken );
    }

    public DropCatalogResponse dropCatalog( DropCatalogRequest request_ )
    {
        DropCatalogResponse actualResponse_ = SubmitRequest<DropCatalogResponse>("/drop/catalog", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DropCatalogResponse> DropCatalogAsync( DropCatalogRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        DropCatalogResponse actualResponse_ = await SubmitRequestAsync<DropCatalogResponse>("/drop/catalog", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DropCatalogResponse dropCatalog( string name,
                                            IDictionary<string, string> options = null )
    {
        return dropCatalog( new DropCatalogRequest( name, options ) );
    }

    public async System.Threading.Tasks.Task<DropCatalogResponse> DropCatalogAsync( string name,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await DropCatalogAsync( new DropCatalogRequest( name, options ), cancellationToken );
    }

    public DropContainerRegistryResponse dropContainerRegistry( DropContainerRegistryRequest request_ )
    {
        DropContainerRegistryResponse actualResponse_ = SubmitRequest<DropContainerRegistryResponse>("/drop/container/registry", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DropContainerRegistryResponse> DropContainerRegistryAsync( DropContainerRegistryRequest request_,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        DropContainerRegistryResponse actualResponse_ = await SubmitRequestAsync<DropContainerRegistryResponse>("/drop/container/registry", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DropContainerRegistryResponse dropContainerRegistry( string registry_name,
                                                                IDictionary<string, string> options = null )
    {
        return dropContainerRegistry( new DropContainerRegistryRequest( registry_name,
                                                                        options ) );
    }

    public async System.Threading.Tasks.Task<DropContainerRegistryResponse> DropContainerRegistryAsync( string registry_name,
                                                                                                        IDictionary<string, string> options = null,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await DropContainerRegistryAsync( new DropContainerRegistryRequest( registry_name,
                                                                                   options ), cancellationToken );
    }

    public DropCredentialResponse dropCredential( DropCredentialRequest request_ )
    {
        DropCredentialResponse actualResponse_ = SubmitRequest<DropCredentialResponse>("/drop/credential", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DropCredentialResponse> DropCredentialAsync( DropCredentialRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        DropCredentialResponse actualResponse_ = await SubmitRequestAsync<DropCredentialResponse>("/drop/credential", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DropCredentialResponse dropCredential( string credential_name,
                                                  IDictionary<string, string> options = null )
    {
        return dropCredential( new DropCredentialRequest( credential_name, options ) );
    }

    public async System.Threading.Tasks.Task<DropCredentialResponse> DropCredentialAsync( string credential_name,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await DropCredentialAsync( new DropCredentialRequest( credential_name,
                                                                     options ), cancellationToken );
    }

    public DropDatasinkResponse dropDatasink( DropDatasinkRequest request_ )
    {
        DropDatasinkResponse actualResponse_ = SubmitRequest<DropDatasinkResponse>("/drop/datasink", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DropDatasinkResponse> DropDatasinkAsync( DropDatasinkRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        DropDatasinkResponse actualResponse_ = await SubmitRequestAsync<DropDatasinkResponse>("/drop/datasink", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DropDatasinkResponse dropDatasink( string name,
                                              IDictionary<string, string> options = null )
    {
        return dropDatasink( new DropDatasinkRequest( name, options ) );
    }

    public async System.Threading.Tasks.Task<DropDatasinkResponse> DropDatasinkAsync( string name,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await DropDatasinkAsync( new DropDatasinkRequest( name, options ), cancellationToken );
    }

    public DropDatasourceResponse dropDatasource( DropDatasourceRequest request_ )
    {
        DropDatasourceResponse actualResponse_ = SubmitRequest<DropDatasourceResponse>("/drop/datasource", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DropDatasourceResponse> DropDatasourceAsync( DropDatasourceRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        DropDatasourceResponse actualResponse_ = await SubmitRequestAsync<DropDatasourceResponse>("/drop/datasource", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DropDatasourceResponse dropDatasource( string name,
                                                  IDictionary<string, string> options = null )
    {
        return dropDatasource( new DropDatasourceRequest( name, options ) );
    }

    public async System.Threading.Tasks.Task<DropDatasourceResponse> DropDatasourceAsync( string name,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await DropDatasourceAsync( new DropDatasourceRequest( name, options ), cancellationToken );
    }

    public DropEnvironmentResponse dropEnvironment( DropEnvironmentRequest request_ )
    {
        DropEnvironmentResponse actualResponse_ = SubmitRequest<DropEnvironmentResponse>("/drop/environment", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DropEnvironmentResponse> DropEnvironmentAsync( DropEnvironmentRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        DropEnvironmentResponse actualResponse_ = await SubmitRequestAsync<DropEnvironmentResponse>("/drop/environment", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DropEnvironmentResponse dropEnvironment( string environment_name,
                                                    IDictionary<string, string> options = null )
    {
        return dropEnvironment( new DropEnvironmentRequest( environment_name, options ) );
    }

    public async System.Threading.Tasks.Task<DropEnvironmentResponse> DropEnvironmentAsync( string environment_name,
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await DropEnvironmentAsync( new DropEnvironmentRequest( environment_name,
                                                                       options ), cancellationToken );
    }

    public DropModelResponse dropModel( DropModelRequest request_ )
    {
        DropModelResponse actualResponse_ = SubmitRequest<DropModelResponse>("/drop/model", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DropModelResponse> DropModelAsync( DropModelRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        DropModelResponse actualResponse_ = await SubmitRequestAsync<DropModelResponse>("/drop/model", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DropModelResponse dropModel( string model_name,
                                        IDictionary<string, string> options = null )
    {
        return dropModel( new DropModelRequest( model_name, options ) );
    }

    public async System.Threading.Tasks.Task<DropModelResponse> DropModelAsync( string model_name,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await DropModelAsync( new DropModelRequest( model_name, options ), cancellationToken );
    }

    public DropSchemaResponse dropSchema( DropSchemaRequest request_ )
    {
        DropSchemaResponse actualResponse_ = SubmitRequest<DropSchemaResponse>("/drop/schema", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<DropSchemaResponse> DropSchemaAsync( DropSchemaRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        DropSchemaResponse actualResponse_ = await SubmitRequestAsync<DropSchemaResponse>("/drop/schema", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public DropSchemaResponse dropSchema( string schema_name,
                                          IDictionary<string, string> options = null )
    {
        return dropSchema( new DropSchemaRequest( schema_name, options ) );
    }

    public async System.Threading.Tasks.Task<DropSchemaResponse> DropSchemaAsync( string schema_name,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await DropSchemaAsync( new DropSchemaRequest( schema_name, options ), cancellationToken );
    }

    public EvaluateModelResponse evaluateModel( EvaluateModelRequest request_ )
    {
        EvaluateModelResponse actualResponse_ = SubmitRequest<EvaluateModelResponse>("/evaluate/model", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<EvaluateModelResponse> EvaluateModelAsync( EvaluateModelRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        EvaluateModelResponse actualResponse_ = await SubmitRequestAsync<EvaluateModelResponse>("/evaluate/model", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public EvaluateModelResponse evaluateModel( string model_name,
                                                int replicas,
                                                string deployment_mode,
                                                string source_table,
                                                string destination_table,
                                                IDictionary<string, string> options = null )
    {
        return evaluateModel( new EvaluateModelRequest( model_name, replicas,
                                                        deployment_mode, source_table,
                                                        destination_table, options ) );
    }

    public async System.Threading.Tasks.Task<EvaluateModelResponse> EvaluateModelAsync( string model_name,
                                                                                        int replicas,
                                                                                        string deployment_mode,
                                                                                        string source_table,
                                                                                        string destination_table,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await EvaluateModelAsync( new EvaluateModelRequest( model_name, replicas,
                                                                   deployment_mode,
                                                                   source_table,
                                                                   destination_table,
                                                                   options ), cancellationToken );
    }

    public ExecuteProcResponse executeProc( ExecuteProcRequest request_ )
    {
        ExecuteProcResponse actualResponse_ = SubmitRequest<ExecuteProcResponse>("/execute/proc", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ExecuteProcResponse> ExecuteProcAsync( ExecuteProcRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        ExecuteProcResponse actualResponse_ = await SubmitRequestAsync<ExecuteProcResponse>("/execute/proc", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ExecuteProcResponse executeProc( string proc_name,
                                            IDictionary<string, string> _params = null,
                                            IDictionary<string, byte[]> bin_params = null,
                                            IList<string> input_table_names = null,
                                            IDictionary<string, IList<string>> input_column_names = null,
                                            IList<string> output_table_names = null,
                                            IDictionary<string, string> options = null )
    {
        return executeProc( new ExecuteProcRequest( proc_name, _params, bin_params,
                                                    input_table_names, input_column_names,
                                                    output_table_names, options ) );
    }

    public async System.Threading.Tasks.Task<ExecuteProcResponse> ExecuteProcAsync( string proc_name,
                                                                                    IDictionary<string, string> _params = null,
                                                                                    IDictionary<string, byte[]> bin_params = null,
                                                                                    IList<string> input_table_names = null,
                                                                                    IDictionary<string, IList<string>> input_column_names = null,
                                                                                    IList<string> output_table_names = null,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await ExecuteProcAsync( new ExecuteProcRequest( proc_name, _params,
                                                               bin_params,
                                                               input_table_names,
                                                               input_column_names,
                                                               output_table_names, options ), cancellationToken );
    }

    public ExecuteSqlResponse executeSql( ExecuteSqlRequest request_ )
    {
        RawExecuteSqlResponse actualResponse_ = SubmitRequest<RawExecuteSqlResponse>("/execute/sql", request_, false);

        ExecuteSqlResponse response_ = new ExecuteSqlResponse();
        response_.count_affected = actualResponse_.count_affected;
        response_.data = KineticaRecord.DecodeDynamicTableRecords( actualResponse_.response_schema_str, actualResponse_.binary_encoded_response );
        response_.total_number_of_records = actualResponse_.total_number_of_records;
        response_.has_more_records = actualResponse_.has_more_records;
        response_.paging_table = actualResponse_.paging_table;
        response_.info = actualResponse_.info;
        return response_;
    }

    public async System.Threading.Tasks.Task<ExecuteSqlResponse> ExecuteSqlAsync( ExecuteSqlRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        RawExecuteSqlResponse actualResponse_ = await SubmitRequestAsync<RawExecuteSqlResponse>("/execute/sql", request_, false, true, cancellationToken);

        ExecuteSqlResponse response_ = new ExecuteSqlResponse();
        response_.count_affected = actualResponse_.count_affected;
        response_.data = KineticaRecord.DecodeDynamicTableRecords( actualResponse_.response_schema_str, actualResponse_.binary_encoded_response );
        response_.total_number_of_records = actualResponse_.total_number_of_records;
        response_.has_more_records = actualResponse_.has_more_records;
        response_.paging_table = actualResponse_.paging_table;
        response_.info = actualResponse_.info;
        return response_;
    }

    public ExecuteSqlResponse executeSql( string statement,
                                          long offset = 0,
                                          long limit = -9999,
                                          string request_schema_str = "",
                                          IList<byte[]> data = null,
                                          IDictionary<string, string> options = null )
    {
        return executeSql( new ExecuteSqlRequest( statement, offset, limit,
                                                  request_schema_str, data, options ) );
    }

    public async System.Threading.Tasks.Task<ExecuteSqlResponse> ExecuteSqlAsync( string statement,
                                                                                  long offset = 0,
                                                                                  long limit = -9999,
                                                                                  string request_schema_str = "",
                                                                                  IList<byte[]> data = null,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await ExecuteSqlAsync( new ExecuteSqlRequest( statement, offset, limit,
                                                             request_schema_str, data,
                                                             options ), cancellationToken );
    }

    public ExportQueryMetricsResponse exportQueryMetrics( ExportQueryMetricsRequest request_ )
    {
        ExportQueryMetricsResponse actualResponse_ = SubmitRequest<ExportQueryMetricsResponse>("/export/query/metrics", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ExportQueryMetricsResponse> ExportQueryMetricsAsync( ExportQueryMetricsRequest request_,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        ExportQueryMetricsResponse actualResponse_ = await SubmitRequestAsync<ExportQueryMetricsResponse>("/export/query/metrics", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ExportQueryMetricsResponse exportQueryMetrics( IDictionary<string, string> options = null )
    {
        return exportQueryMetrics( new ExportQueryMetricsRequest( options ) );
    }

    public async System.Threading.Tasks.Task<ExportQueryMetricsResponse> ExportQueryMetricsAsync( IDictionary<string, string> options = null,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await ExportQueryMetricsAsync( new ExportQueryMetricsRequest( options ), cancellationToken );
    }

    public ExportRecordsToFilesResponse exportRecordsToFiles( ExportRecordsToFilesRequest request_ )
    {
        ExportRecordsToFilesResponse actualResponse_ = SubmitRequest<ExportRecordsToFilesResponse>("/export/records/tofiles", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ExportRecordsToFilesResponse> ExportRecordsToFilesAsync( ExportRecordsToFilesRequest request_,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        ExportRecordsToFilesResponse actualResponse_ = await SubmitRequestAsync<ExportRecordsToFilesResponse>("/export/records/tofiles", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ExportRecordsToFilesResponse exportRecordsToFiles( string table_name,
                                                              string filepath,
                                                              IDictionary<string, string> options = null )
    {
        return exportRecordsToFiles( new ExportRecordsToFilesRequest( table_name,
                                                                      filepath, options ) );
    }

    public async System.Threading.Tasks.Task<ExportRecordsToFilesResponse> ExportRecordsToFilesAsync( string table_name,
                                                                                                      string filepath,
                                                                                                      IDictionary<string, string> options = null,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await ExportRecordsToFilesAsync( new ExportRecordsToFilesRequest( table_name,
                                                                                 filepath,
                                                                                 options ), cancellationToken );
    }

    public ExportRecordsToTableResponse exportRecordsToTable( ExportRecordsToTableRequest request_ )
    {
        ExportRecordsToTableResponse actualResponse_ = SubmitRequest<ExportRecordsToTableResponse>("/export/records/totable", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ExportRecordsToTableResponse> ExportRecordsToTableAsync( ExportRecordsToTableRequest request_,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        ExportRecordsToTableResponse actualResponse_ = await SubmitRequestAsync<ExportRecordsToTableResponse>("/export/records/totable", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ExportRecordsToTableResponse exportRecordsToTable( string table_name,
                                                              string remote_query = "",
                                                              IDictionary<string, string> options = null )
    {
        return exportRecordsToTable( new ExportRecordsToTableRequest( table_name,
                                                                      remote_query,
                                                                      options ) );
    }

    public async System.Threading.Tasks.Task<ExportRecordsToTableResponse> ExportRecordsToTableAsync( string table_name,
                                                                                                      string remote_query = "",
                                                                                                      IDictionary<string, string> options = null,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await ExportRecordsToTableAsync( new ExportRecordsToTableRequest( table_name,
                                                                                 remote_query,
                                                                                 options ), cancellationToken );
    }

    public FilterResponse filter( FilterRequest request_ )
    {
        FilterResponse actualResponse_ = SubmitRequest<FilterResponse>("/filter", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterResponse> FilterAsync( FilterRequest request_,
                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        FilterResponse actualResponse_ = await SubmitRequestAsync<FilterResponse>("/filter", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterResponse filter( string table_name,
                                  string view_name,
                                  string expression,
                                  IDictionary<string, string> options = null )
    {
        return filter( new FilterRequest( table_name, view_name, expression, options ) );
    }

    public async System.Threading.Tasks.Task<FilterResponse> FilterAsync( string table_name,
                                                                          string view_name,
                                                                          string expression,
                                                                          IDictionary<string, string> options = null,
                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterAsync( new FilterRequest( table_name, view_name, expression,
                                                     options ), cancellationToken );
    }

    public FilterByAreaResponse filterByArea( FilterByAreaRequest request_ )
    {
        FilterByAreaResponse actualResponse_ = SubmitRequest<FilterByAreaResponse>("/filter/byarea", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterByAreaResponse> FilterByAreaAsync( FilterByAreaRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        FilterByAreaResponse actualResponse_ = await SubmitRequestAsync<FilterByAreaResponse>("/filter/byarea", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterByAreaResponse filterByArea( string table_name,
                                              string view_name,
                                              string x_column_name,
                                              IList<double> x_vector,
                                              string y_column_name,
                                              IList<double> y_vector,
                                              IDictionary<string, string> options = null )
    {
        return filterByArea( new FilterByAreaRequest( table_name, view_name,
                                                      x_column_name, x_vector,
                                                      y_column_name, y_vector, options ) );
    }

    public async System.Threading.Tasks.Task<FilterByAreaResponse> FilterByAreaAsync( string table_name,
                                                                                      string view_name,
                                                                                      string x_column_name,
                                                                                      IList<double> x_vector,
                                                                                      string y_column_name,
                                                                                      IList<double> y_vector,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterByAreaAsync( new FilterByAreaRequest( table_name, view_name,
                                                                 x_column_name, x_vector,
                                                                 y_column_name, y_vector,
                                                                 options ), cancellationToken );
    }

    public FilterByAreaGeometryResponse filterByAreaGeometry( FilterByAreaGeometryRequest request_ )
    {
        FilterByAreaGeometryResponse actualResponse_ = SubmitRequest<FilterByAreaGeometryResponse>("/filter/byarea/geometry", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterByAreaGeometryResponse> FilterByAreaGeometryAsync( FilterByAreaGeometryRequest request_,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        FilterByAreaGeometryResponse actualResponse_ = await SubmitRequestAsync<FilterByAreaGeometryResponse>("/filter/byarea/geometry", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterByAreaGeometryResponse filterByAreaGeometry( string table_name,
                                                              string view_name,
                                                              string column_name,
                                                              IList<double> x_vector,
                                                              IList<double> y_vector,
                                                              IDictionary<string, string> options = null )
    {
        return filterByAreaGeometry( new FilterByAreaGeometryRequest( table_name,
                                                                      view_name,
                                                                      column_name,
                                                                      x_vector, y_vector,
                                                                      options ) );
    }

    public async System.Threading.Tasks.Task<FilterByAreaGeometryResponse> FilterByAreaGeometryAsync( string table_name,
                                                                                                      string view_name,
                                                                                                      string column_name,
                                                                                                      IList<double> x_vector,
                                                                                                      IList<double> y_vector,
                                                                                                      IDictionary<string, string> options = null,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterByAreaGeometryAsync( new FilterByAreaGeometryRequest( table_name,
                                                                                 view_name,
                                                                                 column_name,
                                                                                 x_vector,
                                                                                 y_vector,
                                                                                 options ), cancellationToken );
    }

    public FilterByBoxResponse filterByBox( FilterByBoxRequest request_ )
    {
        FilterByBoxResponse actualResponse_ = SubmitRequest<FilterByBoxResponse>("/filter/bybox", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterByBoxResponse> FilterByBoxAsync( FilterByBoxRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        FilterByBoxResponse actualResponse_ = await SubmitRequestAsync<FilterByBoxResponse>("/filter/bybox", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterByBoxResponse filterByBox( string table_name,
                                            string view_name,
                                            string x_column_name,
                                            double min_x,
                                            double max_x,
                                            string y_column_name,
                                            double min_y,
                                            double max_y,
                                            IDictionary<string, string> options = null )
    {
        return filterByBox( new FilterByBoxRequest( table_name, view_name, x_column_name,
                                                    min_x, max_x, y_column_name, min_y,
                                                    max_y, options ) );
    }

    public async System.Threading.Tasks.Task<FilterByBoxResponse> FilterByBoxAsync( string table_name,
                                                                                    string view_name,
                                                                                    string x_column_name,
                                                                                    double min_x,
                                                                                    double max_x,
                                                                                    string y_column_name,
                                                                                    double min_y,
                                                                                    double max_y,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterByBoxAsync( new FilterByBoxRequest( table_name, view_name,
                                                               x_column_name, min_x,
                                                               max_x, y_column_name,
                                                               min_y, max_y, options ), cancellationToken );
    }

    public FilterByBoxGeometryResponse filterByBoxGeometry( FilterByBoxGeometryRequest request_ )
    {
        FilterByBoxGeometryResponse actualResponse_ = SubmitRequest<FilterByBoxGeometryResponse>("/filter/bybox/geometry", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterByBoxGeometryResponse> FilterByBoxGeometryAsync( FilterByBoxGeometryRequest request_,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        FilterByBoxGeometryResponse actualResponse_ = await SubmitRequestAsync<FilterByBoxGeometryResponse>("/filter/bybox/geometry", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterByBoxGeometryResponse filterByBoxGeometry( string table_name,
                                                            string view_name,
                                                            string column_name,
                                                            double min_x,
                                                            double max_x,
                                                            double min_y,
                                                            double max_y,
                                                            IDictionary<string, string> options = null )
    {
        return filterByBoxGeometry( new FilterByBoxGeometryRequest( table_name, view_name,
                                                                    column_name, min_x,
                                                                    max_x, min_y, max_y,
                                                                    options ) );
    }

    public async System.Threading.Tasks.Task<FilterByBoxGeometryResponse> FilterByBoxGeometryAsync( string table_name,
                                                                                                    string view_name,
                                                                                                    string column_name,
                                                                                                    double min_x,
                                                                                                    double max_x,
                                                                                                    double min_y,
                                                                                                    double max_y,
                                                                                                    IDictionary<string, string> options = null,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterByBoxGeometryAsync( new FilterByBoxGeometryRequest( table_name,
                                                                               view_name,
                                                                               column_name,
                                                                               min_x,
                                                                               max_x,
                                                                               min_y,
                                                                               max_y,
                                                                               options ), cancellationToken );
    }

    public FilterByGeometryResponse filterByGeometry( FilterByGeometryRequest request_ )
    {
        FilterByGeometryResponse actualResponse_ = SubmitRequest<FilterByGeometryResponse>("/filter/bygeometry", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterByGeometryResponse> FilterByGeometryAsync( FilterByGeometryRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        FilterByGeometryResponse actualResponse_ = await SubmitRequestAsync<FilterByGeometryResponse>("/filter/bygeometry", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterByGeometryResponse filterByGeometry( string table_name,
                                                      string view_name,
                                                      string column_name,
                                                      string input_wkt,
                                                      string operation,
                                                      IDictionary<string, string> options = null )
    {
        return filterByGeometry( new FilterByGeometryRequest( table_name, view_name,
                                                              column_name, input_wkt,
                                                              operation, options ) );
    }

    public async System.Threading.Tasks.Task<FilterByGeometryResponse> FilterByGeometryAsync( string table_name,
                                                                                              string view_name,
                                                                                              string column_name,
                                                                                              string input_wkt,
                                                                                              string operation,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterByGeometryAsync( new FilterByGeometryRequest( table_name,
                                                                         view_name,
                                                                         column_name,
                                                                         input_wkt,
                                                                         operation,
                                                                         options ), cancellationToken );
    }

    public FilterByListResponse filterByList( FilterByListRequest request_ )
    {
        FilterByListResponse actualResponse_ = SubmitRequest<FilterByListResponse>("/filter/bylist", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterByListResponse> FilterByListAsync( FilterByListRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        FilterByListResponse actualResponse_ = await SubmitRequestAsync<FilterByListResponse>("/filter/bylist", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterByListResponse filterByList( string table_name,
                                              string view_name,
                                              IDictionary<string, IList<string>> column_values_map,
                                              IDictionary<string, string> options = null )
    {
        return filterByList( new FilterByListRequest( table_name, view_name,
                                                      column_values_map, options ) );
    }

    public async System.Threading.Tasks.Task<FilterByListResponse> FilterByListAsync( string table_name,
                                                                                      string view_name,
                                                                                      IDictionary<string, IList<string>> column_values_map,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterByListAsync( new FilterByListRequest( table_name, view_name,
                                                                 column_values_map,
                                                                 options ), cancellationToken );
    }

    public FilterByRadiusResponse filterByRadius( FilterByRadiusRequest request_ )
    {
        FilterByRadiusResponse actualResponse_ = SubmitRequest<FilterByRadiusResponse>("/filter/byradius", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterByRadiusResponse> FilterByRadiusAsync( FilterByRadiusRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        FilterByRadiusResponse actualResponse_ = await SubmitRequestAsync<FilterByRadiusResponse>("/filter/byradius", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterByRadiusResponse filterByRadius( string table_name,
                                                  string view_name,
                                                  string x_column_name,
                                                  double x_center,
                                                  string y_column_name,
                                                  double y_center,
                                                  double radius,
                                                  IDictionary<string, string> options = null )
    {
        return filterByRadius( new FilterByRadiusRequest( table_name, view_name,
                                                          x_column_name, x_center,
                                                          y_column_name, y_center, radius,
                                                          options ) );
    }

    public async System.Threading.Tasks.Task<FilterByRadiusResponse> FilterByRadiusAsync( string table_name,
                                                                                          string view_name,
                                                                                          string x_column_name,
                                                                                          double x_center,
                                                                                          string y_column_name,
                                                                                          double y_center,
                                                                                          double radius,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterByRadiusAsync( new FilterByRadiusRequest( table_name,
                                                                     view_name,
                                                                     x_column_name,
                                                                     x_center,
                                                                     y_column_name,
                                                                     y_center, radius,
                                                                     options ), cancellationToken );
    }

    public FilterByRadiusGeometryResponse filterByRadiusGeometry( FilterByRadiusGeometryRequest request_ )
    {
        FilterByRadiusGeometryResponse actualResponse_ = SubmitRequest<FilterByRadiusGeometryResponse>("/filter/byradius/geometry", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterByRadiusGeometryResponse> FilterByRadiusGeometryAsync( FilterByRadiusGeometryRequest request_,
                                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        FilterByRadiusGeometryResponse actualResponse_ = await SubmitRequestAsync<FilterByRadiusGeometryResponse>("/filter/byradius/geometry", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterByRadiusGeometryResponse filterByRadiusGeometry( string table_name,
                                                                  string view_name,
                                                                  string column_name,
                                                                  double x_center,
                                                                  double y_center,
                                                                  double radius,
                                                                  IDictionary<string, string> options = null )
    {
        return filterByRadiusGeometry( new FilterByRadiusGeometryRequest( table_name,
                                                                          view_name,
                                                                          column_name,
                                                                          x_center,
                                                                          y_center,
                                                                          radius, options ) );
    }

    public async System.Threading.Tasks.Task<FilterByRadiusGeometryResponse> FilterByRadiusGeometryAsync( string table_name,
                                                                                                          string view_name,
                                                                                                          string column_name,
                                                                                                          double x_center,
                                                                                                          double y_center,
                                                                                                          double radius,
                                                                                                          IDictionary<string, string> options = null,
                                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterByRadiusGeometryAsync( new FilterByRadiusGeometryRequest( table_name,
                                                                                     view_name,
                                                                                     column_name,
                                                                                     x_center,
                                                                                     y_center,
                                                                                     radius,
                                                                                     options ), cancellationToken );
    }

    public FilterByRangeResponse filterByRange( FilterByRangeRequest request_ )
    {
        FilterByRangeResponse actualResponse_ = SubmitRequest<FilterByRangeResponse>("/filter/byrange", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterByRangeResponse> FilterByRangeAsync( FilterByRangeRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        FilterByRangeResponse actualResponse_ = await SubmitRequestAsync<FilterByRangeResponse>("/filter/byrange", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterByRangeResponse filterByRange( string table_name,
                                                string view_name,
                                                string column_name,
                                                double lower_bound,
                                                double upper_bound,
                                                IDictionary<string, string> options = null )
    {
        return filterByRange( new FilterByRangeRequest( table_name, view_name,
                                                        column_name, lower_bound,
                                                        upper_bound, options ) );
    }

    public async System.Threading.Tasks.Task<FilterByRangeResponse> FilterByRangeAsync( string table_name,
                                                                                        string view_name,
                                                                                        string column_name,
                                                                                        double lower_bound,
                                                                                        double upper_bound,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterByRangeAsync( new FilterByRangeRequest( table_name, view_name,
                                                                   column_name,
                                                                   lower_bound,
                                                                   upper_bound, options ), cancellationToken );
    }

    public FilterBySeriesResponse filterBySeries( FilterBySeriesRequest request_ )
    {
        FilterBySeriesResponse actualResponse_ = SubmitRequest<FilterBySeriesResponse>("/filter/byseries", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterBySeriesResponse> FilterBySeriesAsync( FilterBySeriesRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        FilterBySeriesResponse actualResponse_ = await SubmitRequestAsync<FilterBySeriesResponse>("/filter/byseries", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterBySeriesResponse filterBySeries( string table_name,
                                                  string view_name,
                                                  string track_id,
                                                  IList<string> target_track_ids,
                                                  IDictionary<string, string> options = null )
    {
        return filterBySeries( new FilterBySeriesRequest( table_name, view_name, track_id,
                                                          target_track_ids, options ) );
    }

    public async System.Threading.Tasks.Task<FilterBySeriesResponse> FilterBySeriesAsync( string table_name,
                                                                                          string view_name,
                                                                                          string track_id,
                                                                                          IList<string> target_track_ids,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterBySeriesAsync( new FilterBySeriesRequest( table_name,
                                                                     view_name, track_id,
                                                                     target_track_ids,
                                                                     options ), cancellationToken );
    }

    public FilterByStringResponse filterByString( FilterByStringRequest request_ )
    {
        FilterByStringResponse actualResponse_ = SubmitRequest<FilterByStringResponse>("/filter/bystring", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterByStringResponse> FilterByStringAsync( FilterByStringRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        FilterByStringResponse actualResponse_ = await SubmitRequestAsync<FilterByStringResponse>("/filter/bystring", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterByStringResponse filterByString( string table_name,
                                                  string view_name,
                                                  string expression,
                                                  string mode,
                                                  IList<string> column_names,
                                                  IDictionary<string, string> options = null )
    {
        return filterByString( new FilterByStringRequest( table_name, view_name,
                                                          expression, mode, column_names,
                                                          options ) );
    }

    public async System.Threading.Tasks.Task<FilterByStringResponse> FilterByStringAsync( string table_name,
                                                                                          string view_name,
                                                                                          string expression,
                                                                                          string mode,
                                                                                          IList<string> column_names,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterByStringAsync( new FilterByStringRequest( table_name,
                                                                     view_name,
                                                                     expression, mode,
                                                                     column_names, options ), cancellationToken );
    }

    public FilterByTableResponse filterByTable( FilterByTableRequest request_ )
    {
        FilterByTableResponse actualResponse_ = SubmitRequest<FilterByTableResponse>("/filter/bytable", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterByTableResponse> FilterByTableAsync( FilterByTableRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        FilterByTableResponse actualResponse_ = await SubmitRequestAsync<FilterByTableResponse>("/filter/bytable", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterByTableResponse filterByTable( string table_name,
                                                string view_name,
                                                string column_name,
                                                string source_table_name,
                                                string source_table_column_name,
                                                IDictionary<string, string> options = null )
    {
        return filterByTable( new FilterByTableRequest( table_name, view_name,
                                                        column_name, source_table_name,
                                                        source_table_column_name, options ) );
    }

    public async System.Threading.Tasks.Task<FilterByTableResponse> FilterByTableAsync( string table_name,
                                                                                        string view_name,
                                                                                        string column_name,
                                                                                        string source_table_name,
                                                                                        string source_table_column_name,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterByTableAsync( new FilterByTableRequest( table_name, view_name,
                                                                   column_name,
                                                                   source_table_name,
                                                                   source_table_column_name,
                                                                   options ), cancellationToken );
    }

    public FilterByValueResponse filterByValue( FilterByValueRequest request_ )
    {
        FilterByValueResponse actualResponse_ = SubmitRequest<FilterByValueResponse>("/filter/byvalue", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<FilterByValueResponse> FilterByValueAsync( FilterByValueRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        FilterByValueResponse actualResponse_ = await SubmitRequestAsync<FilterByValueResponse>("/filter/byvalue", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public FilterByValueResponse filterByValue( string table_name,
                                                string view_name,
                                                bool is_string,
                                                double _value,
                                                string value_str,
                                                string column_name,
                                                IDictionary<string, string> options = null )
    {
        return filterByValue( new FilterByValueRequest( table_name, view_name, is_string,
                                                        _value, value_str, column_name,
                                                        options ) );
    }

    public async System.Threading.Tasks.Task<FilterByValueResponse> FilterByValueAsync( string table_name,
                                                                                        string view_name,
                                                                                        bool is_string,
                                                                                        double _value,
                                                                                        string value_str,
                                                                                        string column_name,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await FilterByValueAsync( new FilterByValueRequest( table_name, view_name,
                                                                   is_string, _value,
                                                                   value_str, column_name,
                                                                   options ), cancellationToken );
    }

    public GetGraphEntitiesResponse getGraphEntities( GetGraphEntitiesRequest request_ )
    {
        GetGraphEntitiesResponse actualResponse_ = SubmitRequest<GetGraphEntitiesResponse>("/get/graph/entities", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<GetGraphEntitiesResponse> GetGraphEntitiesAsync( GetGraphEntitiesRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        GetGraphEntitiesResponse actualResponse_ = await SubmitRequestAsync<GetGraphEntitiesResponse>("/get/graph/entities", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public GetGraphEntitiesResponse getGraphEntities( string graph_name,
                                                      long offset = 0,
                                                      long limit = 10000,
                                                      IDictionary<string, string> options = null )
    {
        return getGraphEntities( new GetGraphEntitiesRequest( graph_name, offset, limit,
                                                              options ) );
    }

    public async System.Threading.Tasks.Task<GetGraphEntitiesResponse> GetGraphEntitiesAsync( string graph_name,
                                                                                              long offset = 0,
                                                                                              long limit = 10000,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await GetGraphEntitiesAsync( new GetGraphEntitiesRequest( graph_name,
                                                                         offset, limit,
                                                                         options ), cancellationToken );
    }

    public GetJobResponse getJob( GetJobRequest request_ )
    {
        GetJobResponse actualResponse_ = SubmitRequest<GetJobResponse>("/get/job", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<GetJobResponse> GetJobAsync( GetJobRequest request_,
                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        GetJobResponse actualResponse_ = await SubmitRequestAsync<GetJobResponse>("/get/job", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public GetJobResponse getJob( long job_id,
                                  IDictionary<string, string> options = null )
    {
        return getJob( new GetJobRequest( job_id, options ) );
    }

    public async System.Threading.Tasks.Task<GetJobResponse> GetJobAsync( long job_id,
                                                                          IDictionary<string, string> options = null,
                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await GetJobAsync( new GetJobRequest( job_id, options ), cancellationToken );
    }

    public GetRecordsResponse<T> getRecords<T>( GetRecordsRequest request_ ) where T : new()
    {
        RawGetRecordsResponse actualResponse_ = SubmitRequest<RawGetRecordsResponse>("/get/records", request_, false);

        GetRecordsResponse<T> response_ = new GetRecordsResponse<T>();
        response_.table_name = actualResponse_.table_name;
        response_.type_name = actualResponse_.type_name;
        response_.type_schema = actualResponse_.type_schema;
        response_.data = new List<T>();
        this.DecodeRawBinaryDataUsingSchemaString<T>( response_.type_schema, actualResponse_.records_binary, response_.data );
        response_.total_number_of_records = actualResponse_.total_number_of_records;
        response_.has_more_records = actualResponse_.has_more_records;
        response_.info = actualResponse_.info;
        return response_;
    }

    public async System.Threading.Tasks.Task<GetRecordsResponse<T>> GetRecordsAsync<T>( GetRecordsRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default ) where T : new()
    {
        RawGetRecordsResponse actualResponse_ = await SubmitRequestAsync<RawGetRecordsResponse>("/get/records", request_, false, true, cancellationToken);

        GetRecordsResponse<T> response_ = new GetRecordsResponse<T>();
        response_.table_name = actualResponse_.table_name;
        response_.type_name = actualResponse_.type_name;
        response_.type_schema = actualResponse_.type_schema;
        response_.data = new List<T>();
        this.DecodeRawBinaryDataUsingSchemaString<T>( response_.type_schema, actualResponse_.records_binary, response_.data );
        response_.total_number_of_records = actualResponse_.total_number_of_records;
        response_.has_more_records = actualResponse_.has_more_records;
        response_.info = actualResponse_.info;
        return response_;
    }

    public GetRecordsResponse<T> getRecords<T>( string table_name,
                                                long offset = 0,
                                                long limit = -9999,
                                                IDictionary<string, string> options = null ) where T : new()
    {
        return getRecords<T>( new GetRecordsRequest( table_name, offset, limit, options ) );
    }

    public async System.Threading.Tasks.Task<GetRecordsResponse<T>> GetRecordsAsync<T>( string table_name,
                                                                                        long offset = 0,
                                                                                        long limit = -9999,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default ) where T : new()
    {
        return await GetRecordsAsync<T>( new GetRecordsRequest( table_name, offset, limit,
                                                                options ), cancellationToken );
    }

    public GetRecordsByColumnResponse getRecordsByColumn( GetRecordsByColumnRequest request_ )
    {
        RawGetRecordsByColumnResponse actualResponse_ = SubmitRequest<RawGetRecordsByColumnResponse>("/get/records/bycolumn", request_, false);

        GetRecordsByColumnResponse response_ = new GetRecordsByColumnResponse();
        response_.table_name = actualResponse_.table_name;
        response_.data = KineticaRecord.DecodeDynamicTableRecords( actualResponse_.response_schema_str, actualResponse_.binary_encoded_response );
        response_.total_number_of_records = actualResponse_.total_number_of_records;
        response_.has_more_records = actualResponse_.has_more_records;
        response_.info = actualResponse_.info;
        return response_;
    }

    public async System.Threading.Tasks.Task<GetRecordsByColumnResponse> GetRecordsByColumnAsync( GetRecordsByColumnRequest request_,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        RawGetRecordsByColumnResponse actualResponse_ = await SubmitRequestAsync<RawGetRecordsByColumnResponse>("/get/records/bycolumn", request_, false, true, cancellationToken);

        GetRecordsByColumnResponse response_ = new GetRecordsByColumnResponse();
        response_.table_name = actualResponse_.table_name;
        response_.data = KineticaRecord.DecodeDynamicTableRecords( actualResponse_.response_schema_str, actualResponse_.binary_encoded_response );
        response_.total_number_of_records = actualResponse_.total_number_of_records;
        response_.has_more_records = actualResponse_.has_more_records;
        response_.info = actualResponse_.info;
        return response_;
    }

    public GetRecordsByColumnResponse getRecordsByColumn( string table_name,
                                                          IList<string> column_names,
                                                          long offset = 0,
                                                          long limit = -9999,
                                                          IDictionary<string, string> options = null )
    {
        return getRecordsByColumn( new GetRecordsByColumnRequest( table_name,
                                                                  column_names, offset,
                                                                  limit, options ) );
    }

    public async System.Threading.Tasks.Task<GetRecordsByColumnResponse> GetRecordsByColumnAsync( string table_name,
                                                                                                  IList<string> column_names,
                                                                                                  long offset = 0,
                                                                                                  long limit = -9999,
                                                                                                  IDictionary<string, string> options = null,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await GetRecordsByColumnAsync( new GetRecordsByColumnRequest( table_name,
                                                                             column_names,
                                                                             offset,
                                                                             limit,
                                                                             options ), cancellationToken );
    }

    public GetRecordsBySeriesResponse<T> getRecordsBySeries<T>( GetRecordsBySeriesRequest request_ ) where T : new()
    {
        RawGetRecordsBySeriesResponse actualResponse_ = SubmitRequest<RawGetRecordsBySeriesResponse>("/get/records/byseries", request_, false);

        GetRecordsBySeriesResponse<T> response_ = new GetRecordsBySeriesResponse<T>();
        response_.table_names = actualResponse_.table_names;
        response_.type_names = actualResponse_.type_names;
        response_.type_schemas = actualResponse_.type_schemas;
        response_.data = new List<IList<T>>();
        this.DecodeRawBinaryDataUsingTypeIDs<T>( response_.type_names, actualResponse_.list_records_binary, response_.data );
        response_.info = actualResponse_.info;
        return response_;
    }

    public async System.Threading.Tasks.Task<GetRecordsBySeriesResponse<T>> GetRecordsBySeriesAsync<T>( GetRecordsBySeriesRequest request_,
                                                                                                        System.Threading.CancellationToken cancellationToken = default ) where T : new()
    {
        RawGetRecordsBySeriesResponse actualResponse_ = await SubmitRequestAsync<RawGetRecordsBySeriesResponse>("/get/records/byseries", request_, false, true, cancellationToken);

        GetRecordsBySeriesResponse<T> response_ = new GetRecordsBySeriesResponse<T>();
        response_.table_names = actualResponse_.table_names;
        response_.type_names = actualResponse_.type_names;
        response_.type_schemas = actualResponse_.type_schemas;
        response_.data = new List<IList<T>>();
        this.DecodeRawBinaryDataUsingTypeIDs<T>( response_.type_names, actualResponse_.list_records_binary, response_.data );
        response_.info = actualResponse_.info;
        return response_;
    }

    public GetRecordsBySeriesResponse<T> getRecordsBySeries<T>( string table_name,
                                                                string world_table_name,
                                                                int offset = 0,
                                                                int limit = 250,
                                                                IDictionary<string, string> options = null ) where T : new()
    {
        return getRecordsBySeries<T>( new GetRecordsBySeriesRequest( table_name,
                                                                     world_table_name,
                                                                     offset, limit,
                                                                     options ) );
    }

    public async System.Threading.Tasks.Task<GetRecordsBySeriesResponse<T>> GetRecordsBySeriesAsync<T>( string table_name,
                                                                                                        string world_table_name,
                                                                                                        int offset = 0,
                                                                                                        int limit = 250,
                                                                                                        IDictionary<string, string> options = null,
                                                                                                        System.Threading.CancellationToken cancellationToken = default ) where T : new()
    {
        return await GetRecordsBySeriesAsync<T>( new GetRecordsBySeriesRequest( table_name,
                                                                                world_table_name,
                                                                                offset,
                                                                                limit,
                                                                                options ), cancellationToken );
    }

    public GetRecordsFromCollectionResponse<T> getRecordsFromCollection<T>( GetRecordsFromCollectionRequest request_ ) where T : new()
    {
        RawGetRecordsFromCollectionResponse actualResponse_ = SubmitRequest<RawGetRecordsFromCollectionResponse>("/get/records/fromcollection", request_, false);

        GetRecordsFromCollectionResponse<T> response_ = new GetRecordsFromCollectionResponse<T>();
        response_.table_name = actualResponse_.table_name;
        response_.type_names = actualResponse_.type_names;
        response_.data = new List<T>();
        this.DecodeRawBinaryDataUsingTypeIDs<T>( response_.type_names, actualResponse_.records_binary, response_.data );
        response_.record_ids = actualResponse_.record_ids;
        response_.info = actualResponse_.info;
        return response_;
    }

    public async System.Threading.Tasks.Task<GetRecordsFromCollectionResponse<T>> GetRecordsFromCollectionAsync<T>( GetRecordsFromCollectionRequest request_,
                                                                                                                    System.Threading.CancellationToken cancellationToken = default ) where T : new()
    {
        RawGetRecordsFromCollectionResponse actualResponse_ = await SubmitRequestAsync<RawGetRecordsFromCollectionResponse>("/get/records/fromcollection", request_, false, true, cancellationToken);

        GetRecordsFromCollectionResponse<T> response_ = new GetRecordsFromCollectionResponse<T>();
        response_.table_name = actualResponse_.table_name;
        response_.type_names = actualResponse_.type_names;
        response_.data = new List<T>();
        this.DecodeRawBinaryDataUsingTypeIDs<T>( response_.type_names, actualResponse_.records_binary, response_.data );
        response_.record_ids = actualResponse_.record_ids;
        response_.info = actualResponse_.info;
        return response_;
    }

    public GetRecordsFromCollectionResponse<T> getRecordsFromCollection<T>( string table_name,
                                                                            long offset = 0,
                                                                            long limit = -9999,
                                                                            IDictionary<string, string> options = null ) where T : new()
    {
        return getRecordsFromCollection<T>( new GetRecordsFromCollectionRequest( table_name,
                                                                                 offset,
                                                                                 limit,
                                                                                 options ) );
    }

    public async System.Threading.Tasks.Task<GetRecordsFromCollectionResponse<T>> GetRecordsFromCollectionAsync<T>( string table_name,
                                                                                                                    long offset = 0,
                                                                                                                    long limit = -9999,
                                                                                                                    IDictionary<string, string> options = null,
                                                                                                                    System.Threading.CancellationToken cancellationToken = default ) where T : new()
    {
        return await GetRecordsFromCollectionAsync<T>( new GetRecordsFromCollectionRequest( table_name,
                                                                                            offset,
                                                                                            limit,
                                                                                            options ), cancellationToken );
    }

    public GetVectortileResponse getVectortile( GetVectortileRequest request_ )
    {
        GetVectortileResponse actualResponse_ = SubmitRequest<GetVectortileResponse>("/get/vectortile", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<GetVectortileResponse> GetVectortileAsync( GetVectortileRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        GetVectortileResponse actualResponse_ = await SubmitRequestAsync<GetVectortileResponse>("/get/vectortile", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public GetVectortileResponse getVectortile( IList<string> table_names,
                                                IList<string> column_names,
                                                IDictionary<string, IList<string>> layers,
                                                int tile_x,
                                                int tile_y,
                                                int zoom,
                                                IDictionary<string, string> options = null )
    {
        return getVectortile( new GetVectortileRequest( table_names, column_names, layers,
                                                        tile_x, tile_y, zoom, options ) );
    }

    public async System.Threading.Tasks.Task<GetVectortileResponse> GetVectortileAsync( IList<string> table_names,
                                                                                        IList<string> column_names,
                                                                                        IDictionary<string, IList<string>> layers,
                                                                                        int tile_x,
                                                                                        int tile_y,
                                                                                        int zoom,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await GetVectortileAsync( new GetVectortileRequest( table_names,
                                                                   column_names, layers,
                                                                   tile_x, tile_y, zoom,
                                                                   options ), cancellationToken );
    }

    public GrantPermissionResponse grantPermission( GrantPermissionRequest request_ )
    {
        GrantPermissionResponse actualResponse_ = SubmitRequest<GrantPermissionResponse>("/grant/permission", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<GrantPermissionResponse> GrantPermissionAsync( GrantPermissionRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        GrantPermissionResponse actualResponse_ = await SubmitRequestAsync<GrantPermissionResponse>("/grant/permission", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public GrantPermissionResponse grantPermission( string principal,
                                                    string _object,
                                                    string object_type,
                                                    string permission,
                                                    IDictionary<string, string> options = null )
    {
        return grantPermission( new GrantPermissionRequest( principal, _object,
                                                            object_type, permission,
                                                            options ) );
    }

    public async System.Threading.Tasks.Task<GrantPermissionResponse> GrantPermissionAsync( string principal,
                                                                                            string _object,
                                                                                            string object_type,
                                                                                            string permission,
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await GrantPermissionAsync( new GrantPermissionRequest( principal, _object,
                                                                       object_type,
                                                                       permission, options ), cancellationToken );
    }

    public GrantPermissionCredentialResponse grantPermissionCredential( GrantPermissionCredentialRequest request_ )
    {
        GrantPermissionCredentialResponse actualResponse_ = SubmitRequest<GrantPermissionCredentialResponse>("/grant/permission/credential", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<GrantPermissionCredentialResponse> GrantPermissionCredentialAsync( GrantPermissionCredentialRequest request_,
                                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        GrantPermissionCredentialResponse actualResponse_ = await SubmitRequestAsync<GrantPermissionCredentialResponse>("/grant/permission/credential", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public GrantPermissionCredentialResponse grantPermissionCredential( string name,
                                                                        string permission,
                                                                        string credential_name,
                                                                        IDictionary<string, string> options = null )
    {
        return grantPermissionCredential( new GrantPermissionCredentialRequest( name,
                                                                                permission,
                                                                                credential_name,
                                                                                options ) );
    }

    public async System.Threading.Tasks.Task<GrantPermissionCredentialResponse> GrantPermissionCredentialAsync( string name,
                                                                                                                string permission,
                                                                                                                string credential_name,
                                                                                                                IDictionary<string, string> options = null,
                                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await GrantPermissionCredentialAsync( new GrantPermissionCredentialRequest( name,
                                                                                           permission,
                                                                                           credential_name,
                                                                                           options ), cancellationToken );
    }

    public GrantPermissionDatasourceResponse grantPermissionDatasource( GrantPermissionDatasourceRequest request_ )
    {
        GrantPermissionDatasourceResponse actualResponse_ = SubmitRequest<GrantPermissionDatasourceResponse>("/grant/permission/datasource", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<GrantPermissionDatasourceResponse> GrantPermissionDatasourceAsync( GrantPermissionDatasourceRequest request_,
                                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        GrantPermissionDatasourceResponse actualResponse_ = await SubmitRequestAsync<GrantPermissionDatasourceResponse>("/grant/permission/datasource", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public GrantPermissionDatasourceResponse grantPermissionDatasource( string name,
                                                                        string permission,
                                                                        string datasource_name,
                                                                        IDictionary<string, string> options = null )
    {
        return grantPermissionDatasource( new GrantPermissionDatasourceRequest( name,
                                                                                permission,
                                                                                datasource_name,
                                                                                options ) );
    }

    public async System.Threading.Tasks.Task<GrantPermissionDatasourceResponse> GrantPermissionDatasourceAsync( string name,
                                                                                                                string permission,
                                                                                                                string datasource_name,
                                                                                                                IDictionary<string, string> options = null,
                                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await GrantPermissionDatasourceAsync( new GrantPermissionDatasourceRequest( name,
                                                                                           permission,
                                                                                           datasource_name,
                                                                                           options ), cancellationToken );
    }

    public GrantPermissionDirectoryResponse grantPermissionDirectory( GrantPermissionDirectoryRequest request_ )
    {
        GrantPermissionDirectoryResponse actualResponse_ = SubmitRequest<GrantPermissionDirectoryResponse>("/grant/permission/directory", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<GrantPermissionDirectoryResponse> GrantPermissionDirectoryAsync( GrantPermissionDirectoryRequest request_,
                                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        GrantPermissionDirectoryResponse actualResponse_ = await SubmitRequestAsync<GrantPermissionDirectoryResponse>("/grant/permission/directory", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public GrantPermissionDirectoryResponse grantPermissionDirectory( string name,
                                                                      string permission,
                                                                      string directory_name,
                                                                      IDictionary<string, string> options = null )
    {
        return grantPermissionDirectory( new GrantPermissionDirectoryRequest( name,
                                                                              permission,
                                                                              directory_name,
                                                                              options ) );
    }

    public async System.Threading.Tasks.Task<GrantPermissionDirectoryResponse> GrantPermissionDirectoryAsync( string name,
                                                                                                              string permission,
                                                                                                              string directory_name,
                                                                                                              IDictionary<string, string> options = null,
                                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await GrantPermissionDirectoryAsync( new GrantPermissionDirectoryRequest( name,
                                                                                         permission,
                                                                                         directory_name,
                                                                                         options ), cancellationToken );
    }

    public GrantPermissionProcResponse grantPermissionProc( GrantPermissionProcRequest request_ )
    {
        GrantPermissionProcResponse actualResponse_ = SubmitRequest<GrantPermissionProcResponse>("/grant/permission/proc", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<GrantPermissionProcResponse> GrantPermissionProcAsync( GrantPermissionProcRequest request_,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        GrantPermissionProcResponse actualResponse_ = await SubmitRequestAsync<GrantPermissionProcResponse>("/grant/permission/proc", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public GrantPermissionProcResponse grantPermissionProc( string name,
                                                            string permission,
                                                            string proc_name,
                                                            IDictionary<string, string> options = null )
    {
        return grantPermissionProc( new GrantPermissionProcRequest( name, permission,
                                                                    proc_name, options ) );
    }

    public async System.Threading.Tasks.Task<GrantPermissionProcResponse> GrantPermissionProcAsync( string name,
                                                                                                    string permission,
                                                                                                    string proc_name,
                                                                                                    IDictionary<string, string> options = null,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await GrantPermissionProcAsync( new GrantPermissionProcRequest( name,
                                                                               permission,
                                                                               proc_name,
                                                                               options ), cancellationToken );
    }

    public GrantPermissionSystemResponse grantPermissionSystem( GrantPermissionSystemRequest request_ )
    {
        GrantPermissionSystemResponse actualResponse_ = SubmitRequest<GrantPermissionSystemResponse>("/grant/permission/system", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<GrantPermissionSystemResponse> GrantPermissionSystemAsync( GrantPermissionSystemRequest request_,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        GrantPermissionSystemResponse actualResponse_ = await SubmitRequestAsync<GrantPermissionSystemResponse>("/grant/permission/system", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public GrantPermissionSystemResponse grantPermissionSystem( string name,
                                                                string permission,
                                                                IDictionary<string, string> options = null )
    {
        return grantPermissionSystem( new GrantPermissionSystemRequest( name, permission,
                                                                        options ) );
    }

    public async System.Threading.Tasks.Task<GrantPermissionSystemResponse> GrantPermissionSystemAsync( string name,
                                                                                                        string permission,
                                                                                                        IDictionary<string, string> options = null,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await GrantPermissionSystemAsync( new GrantPermissionSystemRequest( name,
                                                                                   permission,
                                                                                   options ), cancellationToken );
    }

    public GrantPermissionTableResponse grantPermissionTable( GrantPermissionTableRequest request_ )
    {
        GrantPermissionTableResponse actualResponse_ = SubmitRequest<GrantPermissionTableResponse>("/grant/permission/table", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<GrantPermissionTableResponse> GrantPermissionTableAsync( GrantPermissionTableRequest request_,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        GrantPermissionTableResponse actualResponse_ = await SubmitRequestAsync<GrantPermissionTableResponse>("/grant/permission/table", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public GrantPermissionTableResponse grantPermissionTable( string name,
                                                              string permission,
                                                              string table_name,
                                                              string filter_expression = "",
                                                              IDictionary<string, string> options = null )
    {
        return grantPermissionTable( new GrantPermissionTableRequest( name, permission,
                                                                      table_name,
                                                                      filter_expression,
                                                                      options ) );
    }

    public async System.Threading.Tasks.Task<GrantPermissionTableResponse> GrantPermissionTableAsync( string name,
                                                                                                      string permission,
                                                                                                      string table_name,
                                                                                                      string filter_expression = "",
                                                                                                      IDictionary<string, string> options = null,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await GrantPermissionTableAsync( new GrantPermissionTableRequest( name,
                                                                                 permission,
                                                                                 table_name,
                                                                                 filter_expression,
                                                                                 options ), cancellationToken );
    }

    public GrantRoleResponse grantRole( GrantRoleRequest request_ )
    {
        GrantRoleResponse actualResponse_ = SubmitRequest<GrantRoleResponse>("/grant/role", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<GrantRoleResponse> GrantRoleAsync( GrantRoleRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        GrantRoleResponse actualResponse_ = await SubmitRequestAsync<GrantRoleResponse>("/grant/role", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public GrantRoleResponse grantRole( string role,
                                        string member,
                                        IDictionary<string, string> options = null )
    {
        return grantRole( new GrantRoleRequest( role, member, options ) );
    }

    public async System.Threading.Tasks.Task<GrantRoleResponse> GrantRoleAsync( string role,
                                                                                string member,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await GrantRoleAsync( new GrantRoleRequest( role, member, options ), cancellationToken );
    }

    public HasPermissionResponse hasPermission( HasPermissionRequest request_ )
    {
        HasPermissionResponse actualResponse_ = SubmitRequest<HasPermissionResponse>("/has/permission", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<HasPermissionResponse> HasPermissionAsync( HasPermissionRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        HasPermissionResponse actualResponse_ = await SubmitRequestAsync<HasPermissionResponse>("/has/permission", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public HasPermissionResponse hasPermission( string principal,
                                                string _object,
                                                string object_type,
                                                string permission,
                                                IDictionary<string, string> options = null )
    {
        return hasPermission( new HasPermissionRequest( principal, _object, object_type,
                                                        permission, options ) );
    }

    public async System.Threading.Tasks.Task<HasPermissionResponse> HasPermissionAsync( string principal,
                                                                                        string _object,
                                                                                        string object_type,
                                                                                        string permission,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await HasPermissionAsync( new HasPermissionRequest( principal, _object,
                                                                   object_type,
                                                                   permission, options ), cancellationToken );
    }

    public HasProcResponse hasProc( HasProcRequest request_ )
    {
        HasProcResponse actualResponse_ = SubmitRequest<HasProcResponse>("/has/proc", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<HasProcResponse> HasProcAsync( HasProcRequest request_,
                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        HasProcResponse actualResponse_ = await SubmitRequestAsync<HasProcResponse>("/has/proc", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public HasProcResponse hasProc( string proc_name,
                                    IDictionary<string, string> options = null )
    {
        return hasProc( new HasProcRequest( proc_name, options ) );
    }

    public async System.Threading.Tasks.Task<HasProcResponse> HasProcAsync( string proc_name,
                                                                            IDictionary<string, string> options = null,
                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await HasProcAsync( new HasProcRequest( proc_name, options ), cancellationToken );
    }

    public HasRoleResponse hasRole( HasRoleRequest request_ )
    {
        HasRoleResponse actualResponse_ = SubmitRequest<HasRoleResponse>("/has/role", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<HasRoleResponse> HasRoleAsync( HasRoleRequest request_,
                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        HasRoleResponse actualResponse_ = await SubmitRequestAsync<HasRoleResponse>("/has/role", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public HasRoleResponse hasRole( string principal,
                                    string role,
                                    IDictionary<string, string> options = null )
    {
        return hasRole( new HasRoleRequest( principal, role, options ) );
    }

    public async System.Threading.Tasks.Task<HasRoleResponse> HasRoleAsync( string principal,
                                                                            string role,
                                                                            IDictionary<string, string> options = null,
                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await HasRoleAsync( new HasRoleRequest( principal, role, options ), cancellationToken );
    }

    public HasSchemaResponse hasSchema( HasSchemaRequest request_ )
    {
        HasSchemaResponse actualResponse_ = SubmitRequest<HasSchemaResponse>("/has/schema", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<HasSchemaResponse> HasSchemaAsync( HasSchemaRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        HasSchemaResponse actualResponse_ = await SubmitRequestAsync<HasSchemaResponse>("/has/schema", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public HasSchemaResponse hasSchema( string schema_name,
                                        IDictionary<string, string> options = null )
    {
        return hasSchema( new HasSchemaRequest( schema_name, options ) );
    }

    public async System.Threading.Tasks.Task<HasSchemaResponse> HasSchemaAsync( string schema_name,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await HasSchemaAsync( new HasSchemaRequest( schema_name, options ), cancellationToken );
    }

    public HasTableResponse hasTable( HasTableRequest request_ )
    {
        HasTableResponse actualResponse_ = SubmitRequest<HasTableResponse>("/has/table", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<HasTableResponse> HasTableAsync( HasTableRequest request_,
                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        HasTableResponse actualResponse_ = await SubmitRequestAsync<HasTableResponse>("/has/table", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public HasTableResponse hasTable( string table_name,
                                      IDictionary<string, string> options = null )
    {
        return hasTable( new HasTableRequest( table_name, options ) );
    }

    public async System.Threading.Tasks.Task<HasTableResponse> HasTableAsync( string table_name,
                                                                              IDictionary<string, string> options = null,
                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await HasTableAsync( new HasTableRequest( table_name, options ), cancellationToken );
    }

    public HasTypeResponse hasType( HasTypeRequest request_ )
    {
        HasTypeResponse actualResponse_ = SubmitRequest<HasTypeResponse>("/has/type", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<HasTypeResponse> HasTypeAsync( HasTypeRequest request_,
                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        HasTypeResponse actualResponse_ = await SubmitRequestAsync<HasTypeResponse>("/has/type", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public HasTypeResponse hasType( string type_id,
                                    IDictionary<string, string> options = null )
    {
        return hasType( new HasTypeRequest( type_id, options ) );
    }

    public async System.Threading.Tasks.Task<HasTypeResponse> HasTypeAsync( string type_id,
                                                                            IDictionary<string, string> options = null,
                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await HasTypeAsync( new HasTypeRequest( type_id, options ), cancellationToken );
    }

    public ImportModelResponse importModel( ImportModelRequest request_ )
    {
        ImportModelResponse actualResponse_ = SubmitRequest<ImportModelResponse>("/import/model", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ImportModelResponse> ImportModelAsync( ImportModelRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        ImportModelResponse actualResponse_ = await SubmitRequestAsync<ImportModelResponse>("/import/model", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ImportModelResponse importModel( string model_name,
                                            string registry_name,
                                            string container,
                                            string run_function,
                                            string model_type,
                                            IDictionary<string, string> options = null )
    {
        return importModel( new ImportModelRequest( model_name, registry_name, container,
                                                    run_function, model_type, options ) );
    }

    public async System.Threading.Tasks.Task<ImportModelResponse> ImportModelAsync( string model_name,
                                                                                    string registry_name,
                                                                                    string container,
                                                                                    string run_function,
                                                                                    string model_type,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await ImportModelAsync( new ImportModelRequest( model_name, registry_name,
                                                               container, run_function,
                                                               model_type, options ), cancellationToken );
    }

    public InsertRecordsResponse insertRecordsRaw( RawInsertRecordsRequest request_ )
    {
        InsertRecordsResponse actualResponse_ = SubmitRequest<InsertRecordsResponse>("/insert/records", request_, true);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<InsertRecordsResponse> InsertRecordsRawAsync( RawInsertRecordsRequest request_,
                                                                                           System.Threading.CancellationToken cancellationToken = default )
    {
        InsertRecordsResponse actualResponse_ = await SubmitRequestAsync<InsertRecordsResponse>("/insert/records", request_, true, true, cancellationToken);

        return actualResponse_;
    }

    public InsertRecordsResponse insertRecords<T>( InsertRecordsRequest<T> request_ )
    {
        RawInsertRecordsRequest actualRequest_ = new RawInsertRecordsRequest();
        actualRequest_.table_name = request_.table_name;
        foreach (var thisObj in request_.data) actualRequest_.list.Add( AvroEncode( thisObj ) );
        actualRequest_.options = request_.options;
        InsertRecordsResponse actualResponse_ = SubmitRequest<InsertRecordsResponse>("/insert/records", actualRequest_, true);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<InsertRecordsResponse> InsertRecordsAsync<T>( InsertRecordsRequest<T> request_,
                                                                                           System.Threading.CancellationToken cancellationToken = default )
    {
        RawInsertRecordsRequest actualRequest_ = new RawInsertRecordsRequest();
        actualRequest_.table_name = request_.table_name;
        foreach (var thisObj in request_.data) actualRequest_.list.Add( AvroEncode( thisObj ) );
        actualRequest_.options = request_.options;
        InsertRecordsResponse actualResponse_ = await SubmitRequestAsync<InsertRecordsResponse>("/insert/records", actualRequest_, true, true, cancellationToken);

        return actualResponse_;
    }

    public InsertRecordsResponse insertRecords<T>( string table_name,
                                                   IList<T> data,
                                                   IDictionary<string, string> options = null )
    {
        return insertRecords<T>( new InsertRecordsRequest<T>( table_name, data, options ) );
    }

    public async System.Threading.Tasks.Task<InsertRecordsResponse> InsertRecordsAsync<T>( string table_name,
                                                                                           IList<T> data,
                                                                                           IDictionary<string, string> options = null,
                                                                                           System.Threading.CancellationToken cancellationToken = default )
    {
        return await InsertRecordsAsync<T>( new InsertRecordsRequest<T>( table_name, data,
                                                                         options ), cancellationToken );
    }

    public InsertRecordsFromFilesResponse insertRecordsFromFiles( InsertRecordsFromFilesRequest request_ )
    {
        InsertRecordsFromFilesResponse actualResponse_ = SubmitRequest<InsertRecordsFromFilesResponse>("/insert/records/fromfiles", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<InsertRecordsFromFilesResponse> InsertRecordsFromFilesAsync( InsertRecordsFromFilesRequest request_,
                                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        InsertRecordsFromFilesResponse actualResponse_ = await SubmitRequestAsync<InsertRecordsFromFilesResponse>("/insert/records/fromfiles", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public InsertRecordsFromFilesResponse insertRecordsFromFiles( string table_name,
                                                                  IList<string> filepaths,
                                                                  IDictionary<string, IDictionary<string, string>> modify_columns = null,
                                                                  IDictionary<string, string> create_table_options = null,
                                                                  IDictionary<string, string> options = null )
    {
        return insertRecordsFromFiles( new InsertRecordsFromFilesRequest( table_name,
                                                                          filepaths,
                                                                          modify_columns,
                                                                          create_table_options,
                                                                          options ) );
    }

    public async System.Threading.Tasks.Task<InsertRecordsFromFilesResponse> InsertRecordsFromFilesAsync( string table_name,
                                                                                                          IList<string> filepaths,
                                                                                                          IDictionary<string, IDictionary<string, string>> modify_columns = null,
                                                                                                          IDictionary<string, string> create_table_options = null,
                                                                                                          IDictionary<string, string> options = null,
                                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await InsertRecordsFromFilesAsync( new InsertRecordsFromFilesRequest( table_name,
                                                                                     filepaths,
                                                                                     modify_columns,
                                                                                     create_table_options,
                                                                                     options ), cancellationToken );
    }

    public InsertRecordsFromPayloadResponse insertRecordsFromPayload( InsertRecordsFromPayloadRequest request_ )
    {
        InsertRecordsFromPayloadResponse actualResponse_ = SubmitRequest<InsertRecordsFromPayloadResponse>("/insert/records/frompayload", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<InsertRecordsFromPayloadResponse> InsertRecordsFromPayloadAsync( InsertRecordsFromPayloadRequest request_,
                                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        InsertRecordsFromPayloadResponse actualResponse_ = await SubmitRequestAsync<InsertRecordsFromPayloadResponse>("/insert/records/frompayload", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public InsertRecordsFromPayloadResponse insertRecordsFromPayload( string table_name,
                                                                      string data_text,
                                                                      byte[] data_bytes,
                                                                      IDictionary<string, IDictionary<string, string>> modify_columns = null,
                                                                      IDictionary<string, string> create_table_options = null,
                                                                      IDictionary<string, string> options = null )
    {
        return insertRecordsFromPayload( new InsertRecordsFromPayloadRequest( table_name,
                                                                              data_text,
                                                                              data_bytes,
                                                                              modify_columns,
                                                                              create_table_options,
                                                                              options ) );
    }

    public async System.Threading.Tasks.Task<InsertRecordsFromPayloadResponse> InsertRecordsFromPayloadAsync( string table_name,
                                                                                                              string data_text,
                                                                                                              byte[] data_bytes,
                                                                                                              IDictionary<string, IDictionary<string, string>> modify_columns = null,
                                                                                                              IDictionary<string, string> create_table_options = null,
                                                                                                              IDictionary<string, string> options = null,
                                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await InsertRecordsFromPayloadAsync( new InsertRecordsFromPayloadRequest( table_name,
                                                                                         data_text,
                                                                                         data_bytes,
                                                                                         modify_columns,
                                                                                         create_table_options,
                                                                                         options ), cancellationToken );
    }

    public InsertRecordsFromQueryResponse insertRecordsFromQuery( InsertRecordsFromQueryRequest request_ )
    {
        InsertRecordsFromQueryResponse actualResponse_ = SubmitRequest<InsertRecordsFromQueryResponse>("/insert/records/fromquery", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<InsertRecordsFromQueryResponse> InsertRecordsFromQueryAsync( InsertRecordsFromQueryRequest request_,
                                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        InsertRecordsFromQueryResponse actualResponse_ = await SubmitRequestAsync<InsertRecordsFromQueryResponse>("/insert/records/fromquery", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public InsertRecordsFromQueryResponse insertRecordsFromQuery( string table_name,
                                                                  string remote_query,
                                                                  IDictionary<string, IDictionary<string, string>> modify_columns = null,
                                                                  IDictionary<string, string> create_table_options = null,
                                                                  IDictionary<string, string> options = null )
    {
        return insertRecordsFromQuery( new InsertRecordsFromQueryRequest( table_name,
                                                                          remote_query,
                                                                          modify_columns,
                                                                          create_table_options,
                                                                          options ) );
    }

    public async System.Threading.Tasks.Task<InsertRecordsFromQueryResponse> InsertRecordsFromQueryAsync( string table_name,
                                                                                                          string remote_query,
                                                                                                          IDictionary<string, IDictionary<string, string>> modify_columns = null,
                                                                                                          IDictionary<string, string> create_table_options = null,
                                                                                                          IDictionary<string, string> options = null,
                                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await InsertRecordsFromQueryAsync( new InsertRecordsFromQueryRequest( table_name,
                                                                                     remote_query,
                                                                                     modify_columns,
                                                                                     create_table_options,
                                                                                     options ), cancellationToken );
    }

    public InsertRecordsRandomResponse insertRecordsRandom( InsertRecordsRandomRequest request_ )
    {
        InsertRecordsRandomResponse actualResponse_ = SubmitRequest<InsertRecordsRandomResponse>("/insert/records/random", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<InsertRecordsRandomResponse> InsertRecordsRandomAsync( InsertRecordsRandomRequest request_,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        InsertRecordsRandomResponse actualResponse_ = await SubmitRequestAsync<InsertRecordsRandomResponse>("/insert/records/random", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public InsertRecordsRandomResponse insertRecordsRandom( string table_name,
                                                            long count,
                                                            IDictionary<string, IDictionary<string, double>> options = null )
    {
        return insertRecordsRandom( new InsertRecordsRandomRequest( table_name, count,
                                                                    options ) );
    }

    public async System.Threading.Tasks.Task<InsertRecordsRandomResponse> InsertRecordsRandomAsync( string table_name,
                                                                                                    long count,
                                                                                                    IDictionary<string, IDictionary<string, double>> options = null,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await InsertRecordsRandomAsync( new InsertRecordsRandomRequest( table_name,
                                                                               count,
                                                                               options ), cancellationToken );
    }

    public InsertSymbolResponse insertSymbol( InsertSymbolRequest request_ )
    {
        InsertSymbolResponse actualResponse_ = SubmitRequest<InsertSymbolResponse>("/insert/symbol", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<InsertSymbolResponse> InsertSymbolAsync( InsertSymbolRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        InsertSymbolResponse actualResponse_ = await SubmitRequestAsync<InsertSymbolResponse>("/insert/symbol", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public InsertSymbolResponse insertSymbol( string symbol_id,
                                              string symbol_format,
                                              byte[] symbol_data,
                                              IDictionary<string, string> options = null )
    {
        return insertSymbol( new InsertSymbolRequest( symbol_id, symbol_format,
                                                      symbol_data, options ) );
    }

    public async System.Threading.Tasks.Task<InsertSymbolResponse> InsertSymbolAsync( string symbol_id,
                                                                                      string symbol_format,
                                                                                      byte[] symbol_data,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await InsertSymbolAsync( new InsertSymbolRequest( symbol_id, symbol_format,
                                                                 symbol_data, options ), cancellationToken );
    }

    public KillProcResponse killProc( KillProcRequest request_ )
    {
        KillProcResponse actualResponse_ = SubmitRequest<KillProcResponse>("/kill/proc", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<KillProcResponse> KillProcAsync( KillProcRequest request_,
                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        KillProcResponse actualResponse_ = await SubmitRequestAsync<KillProcResponse>("/kill/proc", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public KillProcResponse killProc( string run_id = "",
                                      IDictionary<string, string> options = null )
    {
        return killProc( new KillProcRequest( run_id, options ) );
    }

    public async System.Threading.Tasks.Task<KillProcResponse> KillProcAsync( string run_id = "",
                                                                              IDictionary<string, string> options = null,
                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await KillProcAsync( new KillProcRequest( run_id, options ), cancellationToken );
    }

    public ListGraphResponse listGraph( ListGraphRequest request_ )
    {
        ListGraphResponse actualResponse_ = SubmitRequest<ListGraphResponse>("/list/graph", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ListGraphResponse> ListGraphAsync( ListGraphRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        ListGraphResponse actualResponse_ = await SubmitRequestAsync<ListGraphResponse>("/list/graph", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ListGraphResponse listGraph( string graph_name = "",
                                        IDictionary<string, string> options = null )
    {
        return listGraph( new ListGraphRequest( graph_name, options ) );
    }

    public async System.Threading.Tasks.Task<ListGraphResponse> ListGraphAsync( string graph_name = "",
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await ListGraphAsync( new ListGraphRequest( graph_name, options ), cancellationToken );
    }

    public LockTableResponse lockTable( LockTableRequest request_ )
    {
        LockTableResponse actualResponse_ = SubmitRequest<LockTableResponse>("/lock/table", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<LockTableResponse> LockTableAsync( LockTableRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        LockTableResponse actualResponse_ = await SubmitRequestAsync<LockTableResponse>("/lock/table", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public LockTableResponse lockTable( string table_name,
                                        string lock_type = LockTableRequest.LockType.STATUS,
                                        IDictionary<string, string> options = null )
    {
        return lockTable( new LockTableRequest( table_name, lock_type, options ) );
    }

    public async System.Threading.Tasks.Task<LockTableResponse> LockTableAsync( string table_name,
                                                                                string lock_type = LockTableRequest.LockType.STATUS,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await LockTableAsync( new LockTableRequest( table_name, lock_type, options ), cancellationToken );
    }

    public MatchGraphResponse matchGraph( MatchGraphRequest request_ )
    {
        MatchGraphResponse actualResponse_ = SubmitRequest<MatchGraphResponse>("/match/graph", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<MatchGraphResponse> MatchGraphAsync( MatchGraphRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        MatchGraphResponse actualResponse_ = await SubmitRequestAsync<MatchGraphResponse>("/match/graph", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public MatchGraphResponse matchGraph( string graph_name,
                                          IList<string> sample_points,
                                          string solve_method = MatchGraphRequest.SolveMethod.MARKOV_CHAIN,
                                          string solution_table = "",
                                          IDictionary<string, string> options = null )
    {
        return matchGraph( new MatchGraphRequest( graph_name, sample_points, solve_method,
                                                  solution_table, options ) );
    }

    public async System.Threading.Tasks.Task<MatchGraphResponse> MatchGraphAsync( string graph_name,
                                                                                  IList<string> sample_points,
                                                                                  string solve_method = MatchGraphRequest.SolveMethod.MARKOV_CHAIN,
                                                                                  string solution_table = "",
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await MatchGraphAsync( new MatchGraphRequest( graph_name, sample_points,
                                                             solve_method, solution_table,
                                                             options ), cancellationToken );
    }

    public ModifyGraphResponse modifyGraph( ModifyGraphRequest request_ )
    {
        ModifyGraphResponse actualResponse_ = SubmitRequest<ModifyGraphResponse>("/modify/graph", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ModifyGraphResponse> ModifyGraphAsync( ModifyGraphRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        ModifyGraphResponse actualResponse_ = await SubmitRequestAsync<ModifyGraphResponse>("/modify/graph", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ModifyGraphResponse modifyGraph( string graph_name,
                                            IList<string> nodes,
                                            IList<string> edges,
                                            IList<string> weights,
                                            IList<string> restrictions,
                                            IDictionary<string, string> options = null )
    {
        return modifyGraph( new ModifyGraphRequest( graph_name, nodes, edges, weights,
                                                    restrictions, options ) );
    }

    public async System.Threading.Tasks.Task<ModifyGraphResponse> ModifyGraphAsync( string graph_name,
                                                                                    IList<string> nodes,
                                                                                    IList<string> edges,
                                                                                    IList<string> weights,
                                                                                    IList<string> restrictions,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await ModifyGraphAsync( new ModifyGraphRequest( graph_name, nodes, edges,
                                                               weights, restrictions,
                                                               options ), cancellationToken );
    }

    public QueryGraphResponse queryGraph( QueryGraphRequest request_ )
    {
        QueryGraphResponse actualResponse_ = SubmitRequest<QueryGraphResponse>("/query/graph", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<QueryGraphResponse> QueryGraphAsync( QueryGraphRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        QueryGraphResponse actualResponse_ = await SubmitRequestAsync<QueryGraphResponse>("/query/graph", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public QueryGraphResponse queryGraph( string graph_name,
                                          IList<string> queries,
                                          IList<string> restrictions = null,
                                          string adjacency_table = "",
                                          int rings = 1,
                                          IDictionary<string, string> options = null )
    {
        return queryGraph( new QueryGraphRequest( graph_name, queries, restrictions,
                                                  adjacency_table, rings, options ) );
    }

    public async System.Threading.Tasks.Task<QueryGraphResponse> QueryGraphAsync( string graph_name,
                                                                                  IList<string> queries,
                                                                                  IList<string> restrictions = null,
                                                                                  string adjacency_table = "",
                                                                                  int rings = 1,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await QueryGraphAsync( new QueryGraphRequest( graph_name, queries,
                                                             restrictions,
                                                             adjacency_table, rings,
                                                             options ), cancellationToken );
    }

    public RepartitionGraphResponse repartitionGraph( RepartitionGraphRequest request_ )
    {
        RepartitionGraphResponse actualResponse_ = SubmitRequest<RepartitionGraphResponse>("/repartition/graph", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<RepartitionGraphResponse> RepartitionGraphAsync( RepartitionGraphRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        RepartitionGraphResponse actualResponse_ = await SubmitRequestAsync<RepartitionGraphResponse>("/repartition/graph", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public RepartitionGraphResponse repartitionGraph( string graph_name,
                                                      IDictionary<string, string> options = null )
    {
        return repartitionGraph( new RepartitionGraphRequest( graph_name, options ) );
    }

    public async System.Threading.Tasks.Task<RepartitionGraphResponse> RepartitionGraphAsync( string graph_name,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await RepartitionGraphAsync( new RepartitionGraphRequest( graph_name,
                                                                         options ), cancellationToken );
    }

    public ReserveResourceResponse reserveResource( ReserveResourceRequest request_ )
    {
        ReserveResourceResponse actualResponse_ = SubmitRequest<ReserveResourceResponse>("/reserve/resource", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ReserveResourceResponse> ReserveResourceAsync( ReserveResourceRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        ReserveResourceResponse actualResponse_ = await SubmitRequestAsync<ReserveResourceResponse>("/reserve/resource", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ReserveResourceResponse reserveResource( string component,
                                                    string name,
                                                    string action,
                                                    long bytes_requested = 0,
                                                    long owner_id = 0,
                                                    IDictionary<string, string> options = null )
    {
        return reserveResource( new ReserveResourceRequest( component, name, action,
                                                            bytes_requested, owner_id,
                                                            options ) );
    }

    public async System.Threading.Tasks.Task<ReserveResourceResponse> ReserveResourceAsync( string component,
                                                                                            string name,
                                                                                            string action,
                                                                                            long bytes_requested = 0,
                                                                                            long owner_id = 0,
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await ReserveResourceAsync( new ReserveResourceRequest( component, name,
                                                                       action,
                                                                       bytes_requested,
                                                                       owner_id, options ), cancellationToken );
    }

    public RestoreBackupResponse restoreBackup( RestoreBackupRequest request_ )
    {
        RestoreBackupResponse actualResponse_ = SubmitRequest<RestoreBackupResponse>("/restore/backup", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<RestoreBackupResponse> RestoreBackupAsync( RestoreBackupRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        RestoreBackupResponse actualResponse_ = await SubmitRequestAsync<RestoreBackupResponse>("/restore/backup", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public RestoreBackupResponse restoreBackup( string backup_name,
                                                IDictionary<string, string> restore_objects_map,
                                                string datasource_name,
                                                IDictionary<string, string> options = null )
    {
        return restoreBackup( new RestoreBackupRequest( backup_name, restore_objects_map,
                                                        datasource_name, options ) );
    }

    public async System.Threading.Tasks.Task<RestoreBackupResponse> RestoreBackupAsync( string backup_name,
                                                                                        IDictionary<string, string> restore_objects_map,
                                                                                        string datasource_name,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await RestoreBackupAsync( new RestoreBackupRequest( backup_name,
                                                                   restore_objects_map,
                                                                   datasource_name,
                                                                   options ), cancellationToken );
    }

    public RevokePermissionResponse revokePermission( RevokePermissionRequest request_ )
    {
        RevokePermissionResponse actualResponse_ = SubmitRequest<RevokePermissionResponse>("/revoke/permission", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<RevokePermissionResponse> RevokePermissionAsync( RevokePermissionRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        RevokePermissionResponse actualResponse_ = await SubmitRequestAsync<RevokePermissionResponse>("/revoke/permission", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public RevokePermissionResponse revokePermission( string principal,
                                                      string _object,
                                                      string object_type,
                                                      string permission,
                                                      IDictionary<string, string> options = null )
    {
        return revokePermission( new RevokePermissionRequest( principal, _object,
                                                              object_type, permission,
                                                              options ) );
    }

    public async System.Threading.Tasks.Task<RevokePermissionResponse> RevokePermissionAsync( string principal,
                                                                                              string _object,
                                                                                              string object_type,
                                                                                              string permission,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await RevokePermissionAsync( new RevokePermissionRequest( principal,
                                                                         _object,
                                                                         object_type,
                                                                         permission,
                                                                         options ), cancellationToken );
    }

    public RevokePermissionCredentialResponse revokePermissionCredential( RevokePermissionCredentialRequest request_ )
    {
        RevokePermissionCredentialResponse actualResponse_ = SubmitRequest<RevokePermissionCredentialResponse>("/revoke/permission/credential", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<RevokePermissionCredentialResponse> RevokePermissionCredentialAsync( RevokePermissionCredentialRequest request_,
                                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        RevokePermissionCredentialResponse actualResponse_ = await SubmitRequestAsync<RevokePermissionCredentialResponse>("/revoke/permission/credential", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public RevokePermissionCredentialResponse revokePermissionCredential( string name,
                                                                          string permission,
                                                                          string credential_name,
                                                                          IDictionary<string, string> options = null )
    {
        return revokePermissionCredential( new RevokePermissionCredentialRequest( name,
                                                                                  permission,
                                                                                  credential_name,
                                                                                  options ) );
    }

    public async System.Threading.Tasks.Task<RevokePermissionCredentialResponse> RevokePermissionCredentialAsync( string name,
                                                                                                                  string permission,
                                                                                                                  string credential_name,
                                                                                                                  IDictionary<string, string> options = null,
                                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await RevokePermissionCredentialAsync( new RevokePermissionCredentialRequest( name,
                                                                                             permission,
                                                                                             credential_name,
                                                                                             options ), cancellationToken );
    }

    public RevokePermissionDatasourceResponse revokePermissionDatasource( RevokePermissionDatasourceRequest request_ )
    {
        RevokePermissionDatasourceResponse actualResponse_ = SubmitRequest<RevokePermissionDatasourceResponse>("/revoke/permission/datasource", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<RevokePermissionDatasourceResponse> RevokePermissionDatasourceAsync( RevokePermissionDatasourceRequest request_,
                                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        RevokePermissionDatasourceResponse actualResponse_ = await SubmitRequestAsync<RevokePermissionDatasourceResponse>("/revoke/permission/datasource", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public RevokePermissionDatasourceResponse revokePermissionDatasource( string name,
                                                                          string permission,
                                                                          string datasource_name,
                                                                          IDictionary<string, string> options = null )
    {
        return revokePermissionDatasource( new RevokePermissionDatasourceRequest( name,
                                                                                  permission,
                                                                                  datasource_name,
                                                                                  options ) );
    }

    public async System.Threading.Tasks.Task<RevokePermissionDatasourceResponse> RevokePermissionDatasourceAsync( string name,
                                                                                                                  string permission,
                                                                                                                  string datasource_name,
                                                                                                                  IDictionary<string, string> options = null,
                                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await RevokePermissionDatasourceAsync( new RevokePermissionDatasourceRequest( name,
                                                                                             permission,
                                                                                             datasource_name,
                                                                                             options ), cancellationToken );
    }

    public RevokePermissionDirectoryResponse revokePermissionDirectory( RevokePermissionDirectoryRequest request_ )
    {
        RevokePermissionDirectoryResponse actualResponse_ = SubmitRequest<RevokePermissionDirectoryResponse>("/revoke/permission/directory", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<RevokePermissionDirectoryResponse> RevokePermissionDirectoryAsync( RevokePermissionDirectoryRequest request_,
                                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        RevokePermissionDirectoryResponse actualResponse_ = await SubmitRequestAsync<RevokePermissionDirectoryResponse>("/revoke/permission/directory", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public RevokePermissionDirectoryResponse revokePermissionDirectory( string name,
                                                                        string permission,
                                                                        string directory_name,
                                                                        IDictionary<string, string> options = null )
    {
        return revokePermissionDirectory( new RevokePermissionDirectoryRequest( name,
                                                                                permission,
                                                                                directory_name,
                                                                                options ) );
    }

    public async System.Threading.Tasks.Task<RevokePermissionDirectoryResponse> RevokePermissionDirectoryAsync( string name,
                                                                                                                string permission,
                                                                                                                string directory_name,
                                                                                                                IDictionary<string, string> options = null,
                                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await RevokePermissionDirectoryAsync( new RevokePermissionDirectoryRequest( name,
                                                                                           permission,
                                                                                           directory_name,
                                                                                           options ), cancellationToken );
    }

    public RevokePermissionProcResponse revokePermissionProc( RevokePermissionProcRequest request_ )
    {
        RevokePermissionProcResponse actualResponse_ = SubmitRequest<RevokePermissionProcResponse>("/revoke/permission/proc", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<RevokePermissionProcResponse> RevokePermissionProcAsync( RevokePermissionProcRequest request_,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        RevokePermissionProcResponse actualResponse_ = await SubmitRequestAsync<RevokePermissionProcResponse>("/revoke/permission/proc", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public RevokePermissionProcResponse revokePermissionProc( string name,
                                                              string permission,
                                                              string proc_name,
                                                              IDictionary<string, string> options = null )
    {
        return revokePermissionProc( new RevokePermissionProcRequest( name, permission,
                                                                      proc_name, options ) );
    }

    public async System.Threading.Tasks.Task<RevokePermissionProcResponse> RevokePermissionProcAsync( string name,
                                                                                                      string permission,
                                                                                                      string proc_name,
                                                                                                      IDictionary<string, string> options = null,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await RevokePermissionProcAsync( new RevokePermissionProcRequest( name,
                                                                                 permission,
                                                                                 proc_name,
                                                                                 options ), cancellationToken );
    }

    public RevokePermissionSystemResponse revokePermissionSystem( RevokePermissionSystemRequest request_ )
    {
        RevokePermissionSystemResponse actualResponse_ = SubmitRequest<RevokePermissionSystemResponse>("/revoke/permission/system", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<RevokePermissionSystemResponse> RevokePermissionSystemAsync( RevokePermissionSystemRequest request_,
                                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        RevokePermissionSystemResponse actualResponse_ = await SubmitRequestAsync<RevokePermissionSystemResponse>("/revoke/permission/system", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public RevokePermissionSystemResponse revokePermissionSystem( string name,
                                                                  string permission,
                                                                  IDictionary<string, string> options = null )
    {
        return revokePermissionSystem( new RevokePermissionSystemRequest( name,
                                                                          permission,
                                                                          options ) );
    }

    public async System.Threading.Tasks.Task<RevokePermissionSystemResponse> RevokePermissionSystemAsync( string name,
                                                                                                          string permission,
                                                                                                          IDictionary<string, string> options = null,
                                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await RevokePermissionSystemAsync( new RevokePermissionSystemRequest( name,
                                                                                     permission,
                                                                                     options ), cancellationToken );
    }

    public RevokePermissionTableResponse revokePermissionTable( RevokePermissionTableRequest request_ )
    {
        RevokePermissionTableResponse actualResponse_ = SubmitRequest<RevokePermissionTableResponse>("/revoke/permission/table", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<RevokePermissionTableResponse> RevokePermissionTableAsync( RevokePermissionTableRequest request_,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        RevokePermissionTableResponse actualResponse_ = await SubmitRequestAsync<RevokePermissionTableResponse>("/revoke/permission/table", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public RevokePermissionTableResponse revokePermissionTable( string name,
                                                                string permission,
                                                                string table_name,
                                                                IDictionary<string, string> options = null )
    {
        return revokePermissionTable( new RevokePermissionTableRequest( name, permission,
                                                                        table_name,
                                                                        options ) );
    }

    public async System.Threading.Tasks.Task<RevokePermissionTableResponse> RevokePermissionTableAsync( string name,
                                                                                                        string permission,
                                                                                                        string table_name,
                                                                                                        IDictionary<string, string> options = null,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await RevokePermissionTableAsync( new RevokePermissionTableRequest( name,
                                                                                   permission,
                                                                                   table_name,
                                                                                   options ), cancellationToken );
    }

    public RevokeRoleResponse revokeRole( RevokeRoleRequest request_ )
    {
        RevokeRoleResponse actualResponse_ = SubmitRequest<RevokeRoleResponse>("/revoke/role", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<RevokeRoleResponse> RevokeRoleAsync( RevokeRoleRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        RevokeRoleResponse actualResponse_ = await SubmitRequestAsync<RevokeRoleResponse>("/revoke/role", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public RevokeRoleResponse revokeRole( string role,
                                          string member,
                                          IDictionary<string, string> options = null )
    {
        return revokeRole( new RevokeRoleRequest( role, member, options ) );
    }

    public async System.Threading.Tasks.Task<RevokeRoleResponse> RevokeRoleAsync( string role,
                                                                                  string member,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await RevokeRoleAsync( new RevokeRoleRequest( role, member, options ), cancellationToken );
    }

    public ShowBackupResponse showBackup( ShowBackupRequest request_ )
    {
        ShowBackupResponse actualResponse_ = SubmitRequest<ShowBackupResponse>("/show/backup", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowBackupResponse> ShowBackupAsync( ShowBackupRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        ShowBackupResponse actualResponse_ = await SubmitRequestAsync<ShowBackupResponse>("/show/backup", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowBackupResponse showBackup( string backup_name,
                                          string datasource_name,
                                          IDictionary<string, string> options = null )
    {
        return showBackup( new ShowBackupRequest( backup_name, datasource_name, options ) );
    }

    public async System.Threading.Tasks.Task<ShowBackupResponse> ShowBackupAsync( string backup_name,
                                                                                  string datasource_name,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowBackupAsync( new ShowBackupRequest( backup_name, datasource_name,
                                                             options ), cancellationToken );
    }

    public ShowContainerRegistryResponse showContainerRegistry( ShowContainerRegistryRequest request_ )
    {
        ShowContainerRegistryResponse actualResponse_ = SubmitRequest<ShowContainerRegistryResponse>("/show/container/registry", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowContainerRegistryResponse> ShowContainerRegistryAsync( ShowContainerRegistryRequest request_,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        ShowContainerRegistryResponse actualResponse_ = await SubmitRequestAsync<ShowContainerRegistryResponse>("/show/container/registry", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowContainerRegistryResponse showContainerRegistry( string registry_name,
                                                                IDictionary<string, string> options = null )
    {
        return showContainerRegistry( new ShowContainerRegistryRequest( registry_name,
                                                                        options ) );
    }

    public async System.Threading.Tasks.Task<ShowContainerRegistryResponse> ShowContainerRegistryAsync( string registry_name,
                                                                                                        IDictionary<string, string> options = null,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowContainerRegistryAsync( new ShowContainerRegistryRequest( registry_name,
                                                                                   options ), cancellationToken );
    }

    public ShowCredentialResponse showCredential( ShowCredentialRequest request_ )
    {
        ShowCredentialResponse actualResponse_ = SubmitRequest<ShowCredentialResponse>("/show/credential", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowCredentialResponse> ShowCredentialAsync( ShowCredentialRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        ShowCredentialResponse actualResponse_ = await SubmitRequestAsync<ShowCredentialResponse>("/show/credential", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowCredentialResponse showCredential( string credential_name,
                                                  IDictionary<string, string> options = null )
    {
        return showCredential( new ShowCredentialRequest( credential_name, options ) );
    }

    public async System.Threading.Tasks.Task<ShowCredentialResponse> ShowCredentialAsync( string credential_name,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowCredentialAsync( new ShowCredentialRequest( credential_name,
                                                                     options ), cancellationToken );
    }

    public ShowDatasinkResponse showDatasink( ShowDatasinkRequest request_ )
    {
        ShowDatasinkResponse actualResponse_ = SubmitRequest<ShowDatasinkResponse>("/show/datasink", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowDatasinkResponse> ShowDatasinkAsync( ShowDatasinkRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        ShowDatasinkResponse actualResponse_ = await SubmitRequestAsync<ShowDatasinkResponse>("/show/datasink", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowDatasinkResponse showDatasink( string name,
                                              IDictionary<string, string> options = null )
    {
        return showDatasink( new ShowDatasinkRequest( name, options ) );
    }

    public async System.Threading.Tasks.Task<ShowDatasinkResponse> ShowDatasinkAsync( string name,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowDatasinkAsync( new ShowDatasinkRequest( name, options ), cancellationToken );
    }

    public ShowDatasourceResponse showDatasource( ShowDatasourceRequest request_ )
    {
        ShowDatasourceResponse actualResponse_ = SubmitRequest<ShowDatasourceResponse>("/show/datasource", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowDatasourceResponse> ShowDatasourceAsync( ShowDatasourceRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        ShowDatasourceResponse actualResponse_ = await SubmitRequestAsync<ShowDatasourceResponse>("/show/datasource", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowDatasourceResponse showDatasource( string name,
                                                  IDictionary<string, string> options = null )
    {
        return showDatasource( new ShowDatasourceRequest( name, options ) );
    }

    public async System.Threading.Tasks.Task<ShowDatasourceResponse> ShowDatasourceAsync( string name,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowDatasourceAsync( new ShowDatasourceRequest( name, options ), cancellationToken );
    }

    public ShowDirectoriesResponse showDirectories( ShowDirectoriesRequest request_ )
    {
        ShowDirectoriesResponse actualResponse_ = SubmitRequest<ShowDirectoriesResponse>("/show/directories", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowDirectoriesResponse> ShowDirectoriesAsync( ShowDirectoriesRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        ShowDirectoriesResponse actualResponse_ = await SubmitRequestAsync<ShowDirectoriesResponse>("/show/directories", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowDirectoriesResponse showDirectories( string directory_name = "",
                                                    IDictionary<string, string> options = null )
    {
        return showDirectories( new ShowDirectoriesRequest( directory_name, options ) );
    }

    public async System.Threading.Tasks.Task<ShowDirectoriesResponse> ShowDirectoriesAsync( string directory_name = "",
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowDirectoriesAsync( new ShowDirectoriesRequest( directory_name,
                                                                       options ), cancellationToken );
    }

    public ShowEnvironmentResponse showEnvironment( ShowEnvironmentRequest request_ )
    {
        ShowEnvironmentResponse actualResponse_ = SubmitRequest<ShowEnvironmentResponse>("/show/environment", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowEnvironmentResponse> ShowEnvironmentAsync( ShowEnvironmentRequest request_,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        ShowEnvironmentResponse actualResponse_ = await SubmitRequestAsync<ShowEnvironmentResponse>("/show/environment", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowEnvironmentResponse showEnvironment( string environment_name = "",
                                                    IDictionary<string, string> options = null )
    {
        return showEnvironment( new ShowEnvironmentRequest( environment_name, options ) );
    }

    public async System.Threading.Tasks.Task<ShowEnvironmentResponse> ShowEnvironmentAsync( string environment_name = "",
                                                                                            IDictionary<string, string> options = null,
                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowEnvironmentAsync( new ShowEnvironmentRequest( environment_name,
                                                                       options ), cancellationToken );
    }

    public ShowFilesResponse showFiles( ShowFilesRequest request_ )
    {
        ShowFilesResponse actualResponse_ = SubmitRequest<ShowFilesResponse>("/show/files", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowFilesResponse> ShowFilesAsync( ShowFilesRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        ShowFilesResponse actualResponse_ = await SubmitRequestAsync<ShowFilesResponse>("/show/files", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowFilesResponse showFiles( IList<string> paths,
                                        IDictionary<string, string> options = null )
    {
        return showFiles( new ShowFilesRequest( paths, options ) );
    }

    public async System.Threading.Tasks.Task<ShowFilesResponse> ShowFilesAsync( IList<string> paths,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowFilesAsync( new ShowFilesRequest( paths, options ), cancellationToken );
    }

    public ShowFunctionsResponse showFunctions( ShowFunctionsRequest request_ )
    {
        ShowFunctionsResponse actualResponse_ = SubmitRequest<ShowFunctionsResponse>("/show/functions", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowFunctionsResponse> ShowFunctionsAsync( ShowFunctionsRequest request_,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        ShowFunctionsResponse actualResponse_ = await SubmitRequestAsync<ShowFunctionsResponse>("/show/functions", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowFunctionsResponse showFunctions( IList<string> names,
                                                IDictionary<string, string> options = null )
    {
        return showFunctions( new ShowFunctionsRequest( names, options ) );
    }

    public async System.Threading.Tasks.Task<ShowFunctionsResponse> ShowFunctionsAsync( IList<string> names,
                                                                                        IDictionary<string, string> options = null,
                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowFunctionsAsync( new ShowFunctionsRequest( names, options ), cancellationToken );
    }

    public ShowGraphResponse showGraph( ShowGraphRequest request_ )
    {
        ShowGraphResponse actualResponse_ = SubmitRequest<ShowGraphResponse>("/show/graph", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowGraphResponse> ShowGraphAsync( ShowGraphRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        ShowGraphResponse actualResponse_ = await SubmitRequestAsync<ShowGraphResponse>("/show/graph", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowGraphResponse showGraph( string graph_name = "",
                                        IDictionary<string, string> options = null )
    {
        return showGraph( new ShowGraphRequest( graph_name, options ) );
    }

    public async System.Threading.Tasks.Task<ShowGraphResponse> ShowGraphAsync( string graph_name = "",
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowGraphAsync( new ShowGraphRequest( graph_name, options ), cancellationToken );
    }

    public ShowGraphGrammarResponse showGraphGrammar( ShowGraphGrammarRequest request_ )
    {
        ShowGraphGrammarResponse actualResponse_ = SubmitRequest<ShowGraphGrammarResponse>("/show/graph/grammar", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowGraphGrammarResponse> ShowGraphGrammarAsync( ShowGraphGrammarRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        ShowGraphGrammarResponse actualResponse_ = await SubmitRequestAsync<ShowGraphGrammarResponse>("/show/graph/grammar", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowGraphGrammarResponse showGraphGrammar( IDictionary<string, string> options = null )
    {
        return showGraphGrammar( new ShowGraphGrammarRequest( options ) );
    }

    public async System.Threading.Tasks.Task<ShowGraphGrammarResponse> ShowGraphGrammarAsync( IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowGraphGrammarAsync( new ShowGraphGrammarRequest( options ), cancellationToken );
    }

    public ShowModelResponse showModel( ShowModelRequest request_ )
    {
        ShowModelResponse actualResponse_ = SubmitRequest<ShowModelResponse>("/show/model", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowModelResponse> ShowModelAsync( ShowModelRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        ShowModelResponse actualResponse_ = await SubmitRequestAsync<ShowModelResponse>("/show/model", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowModelResponse showModel( IList<string> model_names = null,
                                        IDictionary<string, string> options = null )
    {
        return showModel( new ShowModelRequest( model_names, options ) );
    }

    public async System.Threading.Tasks.Task<ShowModelResponse> ShowModelAsync( IList<string> model_names = null,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowModelAsync( new ShowModelRequest( model_names, options ), cancellationToken );
    }

    public ShowProcResponse showProc( ShowProcRequest request_ )
    {
        ShowProcResponse actualResponse_ = SubmitRequest<ShowProcResponse>("/show/proc", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowProcResponse> ShowProcAsync( ShowProcRequest request_,
                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        ShowProcResponse actualResponse_ = await SubmitRequestAsync<ShowProcResponse>("/show/proc", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowProcResponse showProc( string proc_name = "",
                                      IDictionary<string, string> options = null )
    {
        return showProc( new ShowProcRequest( proc_name, options ) );
    }

    public async System.Threading.Tasks.Task<ShowProcResponse> ShowProcAsync( string proc_name = "",
                                                                              IDictionary<string, string> options = null,
                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowProcAsync( new ShowProcRequest( proc_name, options ), cancellationToken );
    }

    public ShowProcStatusResponse showProcStatus( ShowProcStatusRequest request_ )
    {
        ShowProcStatusResponse actualResponse_ = SubmitRequest<ShowProcStatusResponse>("/show/proc/status", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowProcStatusResponse> ShowProcStatusAsync( ShowProcStatusRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        ShowProcStatusResponse actualResponse_ = await SubmitRequestAsync<ShowProcStatusResponse>("/show/proc/status", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowProcStatusResponse showProcStatus( string run_id = "",
                                                  IDictionary<string, string> options = null )
    {
        return showProcStatus( new ShowProcStatusRequest( run_id, options ) );
    }

    public async System.Threading.Tasks.Task<ShowProcStatusResponse> ShowProcStatusAsync( string run_id = "",
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowProcStatusAsync( new ShowProcStatusRequest( run_id, options ), cancellationToken );
    }

    public ShowResourceObjectsResponse showResourceObjects( ShowResourceObjectsRequest request_ )
    {
        ShowResourceObjectsResponse actualResponse_ = SubmitRequest<ShowResourceObjectsResponse>("/show/resource/objects", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowResourceObjectsResponse> ShowResourceObjectsAsync( ShowResourceObjectsRequest request_,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        ShowResourceObjectsResponse actualResponse_ = await SubmitRequestAsync<ShowResourceObjectsResponse>("/show/resource/objects", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowResourceObjectsResponse showResourceObjects( IDictionary<string, string> options = null )
    {
        return showResourceObjects( new ShowResourceObjectsRequest( options ) );
    }

    public async System.Threading.Tasks.Task<ShowResourceObjectsResponse> ShowResourceObjectsAsync( IDictionary<string, string> options = null,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowResourceObjectsAsync( new ShowResourceObjectsRequest( options ), cancellationToken );
    }

    public ShowResourceStatisticsResponse showResourceStatistics( ShowResourceStatisticsRequest request_ )
    {
        ShowResourceStatisticsResponse actualResponse_ = SubmitRequest<ShowResourceStatisticsResponse>("/show/resource/statistics", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowResourceStatisticsResponse> ShowResourceStatisticsAsync( ShowResourceStatisticsRequest request_,
                                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        ShowResourceStatisticsResponse actualResponse_ = await SubmitRequestAsync<ShowResourceStatisticsResponse>("/show/resource/statistics", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowResourceStatisticsResponse showResourceStatistics( IDictionary<string, string> options = null )
    {
        return showResourceStatistics( new ShowResourceStatisticsRequest( options ) );
    }

    public async System.Threading.Tasks.Task<ShowResourceStatisticsResponse> ShowResourceStatisticsAsync( IDictionary<string, string> options = null,
                                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowResourceStatisticsAsync( new ShowResourceStatisticsRequest( options ), cancellationToken );
    }

    public ShowResourceGroupsResponse showResourceGroups( ShowResourceGroupsRequest request_ )
    {
        ShowResourceGroupsResponse actualResponse_ = SubmitRequest<ShowResourceGroupsResponse>("/show/resourcegroups", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowResourceGroupsResponse> ShowResourceGroupsAsync( ShowResourceGroupsRequest request_,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        ShowResourceGroupsResponse actualResponse_ = await SubmitRequestAsync<ShowResourceGroupsResponse>("/show/resourcegroups", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowResourceGroupsResponse showResourceGroups( IList<string> names,
                                                          IDictionary<string, string> options = null )
    {
        return showResourceGroups( new ShowResourceGroupsRequest( names, options ) );
    }

    public async System.Threading.Tasks.Task<ShowResourceGroupsResponse> ShowResourceGroupsAsync( IList<string> names,
                                                                                                  IDictionary<string, string> options = null,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowResourceGroupsAsync( new ShowResourceGroupsRequest( names,
                                                                             options ), cancellationToken );
    }

    public ShowSchemaResponse showSchema( ShowSchemaRequest request_ )
    {
        ShowSchemaResponse actualResponse_ = SubmitRequest<ShowSchemaResponse>("/show/schema", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowSchemaResponse> ShowSchemaAsync( ShowSchemaRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        ShowSchemaResponse actualResponse_ = await SubmitRequestAsync<ShowSchemaResponse>("/show/schema", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowSchemaResponse showSchema( string schema_name,
                                          IDictionary<string, string> options = null )
    {
        return showSchema( new ShowSchemaRequest( schema_name, options ) );
    }

    public async System.Threading.Tasks.Task<ShowSchemaResponse> ShowSchemaAsync( string schema_name,
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowSchemaAsync( new ShowSchemaRequest( schema_name, options ), cancellationToken );
    }

    public ShowSecurityResponse showSecurity( ShowSecurityRequest request_ )
    {
        ShowSecurityResponse actualResponse_ = SubmitRequest<ShowSecurityResponse>("/show/security", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowSecurityResponse> ShowSecurityAsync( ShowSecurityRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        ShowSecurityResponse actualResponse_ = await SubmitRequestAsync<ShowSecurityResponse>("/show/security", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowSecurityResponse showSecurity( IList<string> names,
                                              IDictionary<string, string> options = null )
    {
        return showSecurity( new ShowSecurityRequest( names, options ) );
    }

    public async System.Threading.Tasks.Task<ShowSecurityResponse> ShowSecurityAsync( IList<string> names,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowSecurityAsync( new ShowSecurityRequest( names, options ), cancellationToken );
    }

    public ShowSqlProcResponse showSqlProc( ShowSqlProcRequest request_ )
    {
        ShowSqlProcResponse actualResponse_ = SubmitRequest<ShowSqlProcResponse>("/show/sql/proc", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowSqlProcResponse> ShowSqlProcAsync( ShowSqlProcRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        ShowSqlProcResponse actualResponse_ = await SubmitRequestAsync<ShowSqlProcResponse>("/show/sql/proc", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowSqlProcResponse showSqlProc( string procedure_name = "",
                                            IDictionary<string, string> options = null )
    {
        return showSqlProc( new ShowSqlProcRequest( procedure_name, options ) );
    }

    public async System.Threading.Tasks.Task<ShowSqlProcResponse> ShowSqlProcAsync( string procedure_name = "",
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowSqlProcAsync( new ShowSqlProcRequest( procedure_name, options ), cancellationToken );
    }

    public ShowStatisticsResponse showStatistics( ShowStatisticsRequest request_ )
    {
        ShowStatisticsResponse actualResponse_ = SubmitRequest<ShowStatisticsResponse>("/show/statistics", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowStatisticsResponse> ShowStatisticsAsync( ShowStatisticsRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        ShowStatisticsResponse actualResponse_ = await SubmitRequestAsync<ShowStatisticsResponse>("/show/statistics", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowStatisticsResponse showStatistics( IList<string> table_names,
                                                  IDictionary<string, string> options = null )
    {
        return showStatistics( new ShowStatisticsRequest( table_names, options ) );
    }

    public async System.Threading.Tasks.Task<ShowStatisticsResponse> ShowStatisticsAsync( IList<string> table_names,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowStatisticsAsync( new ShowStatisticsRequest( table_names, options ), cancellationToken );
    }

    public ShowSystemPropertiesResponse showSystemProperties( ShowSystemPropertiesRequest request_ )
    {
        ShowSystemPropertiesResponse actualResponse_ = SubmitRequest<ShowSystemPropertiesResponse>("/show/system/properties", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowSystemPropertiesResponse> ShowSystemPropertiesAsync( ShowSystemPropertiesRequest request_,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        ShowSystemPropertiesResponse actualResponse_ = await SubmitRequestAsync<ShowSystemPropertiesResponse>("/show/system/properties", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowSystemPropertiesResponse showSystemProperties( IDictionary<string, string> options = null )
    {
        return showSystemProperties( new ShowSystemPropertiesRequest( options ) );
    }

    public async System.Threading.Tasks.Task<ShowSystemPropertiesResponse> ShowSystemPropertiesAsync( IDictionary<string, string> options = null,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowSystemPropertiesAsync( new ShowSystemPropertiesRequest( options ), cancellationToken );
    }

    public ShowSystemStatusResponse showSystemStatus( ShowSystemStatusRequest request_ )
    {
        ShowSystemStatusResponse actualResponse_ = SubmitRequest<ShowSystemStatusResponse>("/show/system/status", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowSystemStatusResponse> ShowSystemStatusAsync( ShowSystemStatusRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        ShowSystemStatusResponse actualResponse_ = await SubmitRequestAsync<ShowSystemStatusResponse>("/show/system/status", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowSystemStatusResponse showSystemStatus( IDictionary<string, string> options = null )
    {
        return showSystemStatus( new ShowSystemStatusRequest( options ) );
    }

    public async System.Threading.Tasks.Task<ShowSystemStatusResponse> ShowSystemStatusAsync( IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowSystemStatusAsync( new ShowSystemStatusRequest( options ), cancellationToken );
    }

    public ShowSystemTimingResponse showSystemTiming( ShowSystemTimingRequest request_ )
    {
        ShowSystemTimingResponse actualResponse_ = SubmitRequest<ShowSystemTimingResponse>("/show/system/timing", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowSystemTimingResponse> ShowSystemTimingAsync( ShowSystemTimingRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        ShowSystemTimingResponse actualResponse_ = await SubmitRequestAsync<ShowSystemTimingResponse>("/show/system/timing", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowSystemTimingResponse showSystemTiming( IDictionary<string, string> options = null )
    {
        return showSystemTiming( new ShowSystemTimingRequest( options ) );
    }

    public async System.Threading.Tasks.Task<ShowSystemTimingResponse> ShowSystemTimingAsync( IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowSystemTimingAsync( new ShowSystemTimingRequest( options ), cancellationToken );
    }

    public ShowTableResponse showTable( ShowTableRequest request_ )
    {
        ShowTableResponse actualResponse_ = SubmitRequest<ShowTableResponse>("/show/table", request_, false);


        for ( int i_ = 0; i_ < actualResponse_.type_ids.Count; ++i_ )
        {
            SetDecoderIfMissing( actualResponse_.type_ids[i_],
                                 actualResponse_.type_labels[i_],
                                 actualResponse_.type_schemas[i_],
                                 actualResponse_.properties[i_] );
        }

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowTableResponse> ShowTableAsync( ShowTableRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        ShowTableResponse actualResponse_ = await SubmitRequestAsync<ShowTableResponse>("/show/table", request_, false, true, cancellationToken);


        for ( int i_ = 0; i_ < actualResponse_.type_ids.Count; ++i_ )
        {
            SetDecoderIfMissing( actualResponse_.type_ids[i_],
                                 actualResponse_.type_labels[i_],
                                 actualResponse_.type_schemas[i_],
                                 actualResponse_.properties[i_] );
        }

        return actualResponse_;
    }

    public ShowTableResponse showTable( string table_name,
                                        IDictionary<string, string> options = null )
    {
        return showTable( new ShowTableRequest( table_name, options ) );
    }

    public async System.Threading.Tasks.Task<ShowTableResponse> ShowTableAsync( string table_name,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowTableAsync( new ShowTableRequest( table_name, options ), cancellationToken );
    }

    public ShowTableMetadataResponse showTableMetadata( ShowTableMetadataRequest request_ )
    {
        ShowTableMetadataResponse actualResponse_ = SubmitRequest<ShowTableMetadataResponse>("/show/table/metadata", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowTableMetadataResponse> ShowTableMetadataAsync( ShowTableMetadataRequest request_,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        ShowTableMetadataResponse actualResponse_ = await SubmitRequestAsync<ShowTableMetadataResponse>("/show/table/metadata", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowTableMetadataResponse showTableMetadata( IList<string> table_names,
                                                        IDictionary<string, string> options = null )
    {
        return showTableMetadata( new ShowTableMetadataRequest( table_names, options ) );
    }

    public async System.Threading.Tasks.Task<ShowTableMetadataResponse> ShowTableMetadataAsync( IList<string> table_names,
                                                                                                IDictionary<string, string> options = null,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowTableMetadataAsync( new ShowTableMetadataRequest( table_names,
                                                                           options ), cancellationToken );
    }

    public ShowTableMonitorsResponse showTableMonitors( ShowTableMonitorsRequest request_ )
    {
        ShowTableMonitorsResponse actualResponse_ = SubmitRequest<ShowTableMonitorsResponse>("/show/tablemonitors", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowTableMonitorsResponse> ShowTableMonitorsAsync( ShowTableMonitorsRequest request_,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        ShowTableMonitorsResponse actualResponse_ = await SubmitRequestAsync<ShowTableMonitorsResponse>("/show/tablemonitors", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowTableMonitorsResponse showTableMonitors( IList<string> monitor_ids,
                                                        IDictionary<string, string> options = null )
    {
        return showTableMonitors( new ShowTableMonitorsRequest( monitor_ids, options ) );
    }

    public async System.Threading.Tasks.Task<ShowTableMonitorsResponse> ShowTableMonitorsAsync( IList<string> monitor_ids,
                                                                                                IDictionary<string, string> options = null,
                                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowTableMonitorsAsync( new ShowTableMonitorsRequest( monitor_ids,
                                                                           options ), cancellationToken );
    }

    public ShowTablesByTypeResponse showTablesByType( ShowTablesByTypeRequest request_ )
    {
        ShowTablesByTypeResponse actualResponse_ = SubmitRequest<ShowTablesByTypeResponse>("/show/tables/bytype", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowTablesByTypeResponse> ShowTablesByTypeAsync( ShowTablesByTypeRequest request_,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        ShowTablesByTypeResponse actualResponse_ = await SubmitRequestAsync<ShowTablesByTypeResponse>("/show/tables/bytype", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowTablesByTypeResponse showTablesByType( string type_id,
                                                      string label,
                                                      IDictionary<string, string> options = null )
    {
        return showTablesByType( new ShowTablesByTypeRequest( type_id, label, options ) );
    }

    public async System.Threading.Tasks.Task<ShowTablesByTypeResponse> ShowTablesByTypeAsync( string type_id,
                                                                                              string label,
                                                                                              IDictionary<string, string> options = null,
                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowTablesByTypeAsync( new ShowTablesByTypeRequest( type_id, label,
                                                                         options ), cancellationToken );
    }

    public ShowTriggersResponse showTriggers( ShowTriggersRequest request_ )
    {
        ShowTriggersResponse actualResponse_ = SubmitRequest<ShowTriggersResponse>("/show/triggers", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowTriggersResponse> ShowTriggersAsync( ShowTriggersRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        ShowTriggersResponse actualResponse_ = await SubmitRequestAsync<ShowTriggersResponse>("/show/triggers", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowTriggersResponse showTriggers( IList<string> trigger_ids,
                                              IDictionary<string, string> options = null )
    {
        return showTriggers( new ShowTriggersRequest( trigger_ids, options ) );
    }

    public async System.Threading.Tasks.Task<ShowTriggersResponse> ShowTriggersAsync( IList<string> trigger_ids,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowTriggersAsync( new ShowTriggersRequest( trigger_ids, options ), cancellationToken );
    }

    public ShowTypesResponse showTypes( ShowTypesRequest request_ )
    {
        ShowTypesResponse actualResponse_ = SubmitRequest<ShowTypesResponse>("/show/types", request_, false);


        for ( int i_ = 0; i_ < actualResponse_.type_ids.Count; ++i_ )
        {
            SetDecoderIfMissing( actualResponse_.type_ids[i_],
                                 actualResponse_.labels[i_],
                                 actualResponse_.type_schemas[i_],
                                 actualResponse_.properties[i_] );
        }

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowTypesResponse> ShowTypesAsync( ShowTypesRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        ShowTypesResponse actualResponse_ = await SubmitRequestAsync<ShowTypesResponse>("/show/types", request_, false, true, cancellationToken);


        for ( int i_ = 0; i_ < actualResponse_.type_ids.Count; ++i_ )
        {
            SetDecoderIfMissing( actualResponse_.type_ids[i_],
                                 actualResponse_.labels[i_],
                                 actualResponse_.type_schemas[i_],
                                 actualResponse_.properties[i_] );
        }

        return actualResponse_;
    }

    public ShowTypesResponse showTypes( string type_id,
                                        string label,
                                        IDictionary<string, string> options = null )
    {
        return showTypes( new ShowTypesRequest( type_id, label, options ) );
    }

    public async System.Threading.Tasks.Task<ShowTypesResponse> ShowTypesAsync( string type_id,
                                                                                string label,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowTypesAsync( new ShowTypesRequest( type_id, label, options ), cancellationToken );
    }

    public ShowVideoResponse showVideo( ShowVideoRequest request_ )
    {
        ShowVideoResponse actualResponse_ = SubmitRequest<ShowVideoResponse>("/show/video", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowVideoResponse> ShowVideoAsync( ShowVideoRequest request_,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        ShowVideoResponse actualResponse_ = await SubmitRequestAsync<ShowVideoResponse>("/show/video", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowVideoResponse showVideo( IList<string> paths,
                                        IDictionary<string, string> options = null )
    {
        return showVideo( new ShowVideoRequest( paths, options ) );
    }

    public async System.Threading.Tasks.Task<ShowVideoResponse> ShowVideoAsync( IList<string> paths,
                                                                                IDictionary<string, string> options = null,
                                                                                System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowVideoAsync( new ShowVideoRequest( paths, options ), cancellationToken );
    }

    public ShowWalResponse showWal( ShowWalRequest request_ )
    {
        ShowWalResponse actualResponse_ = SubmitRequest<ShowWalResponse>("/show/wal", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<ShowWalResponse> ShowWalAsync( ShowWalRequest request_,
                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        ShowWalResponse actualResponse_ = await SubmitRequestAsync<ShowWalResponse>("/show/wal", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public ShowWalResponse showWal( IList<string> table_names,
                                    IDictionary<string, string> options = null )
    {
        return showWal( new ShowWalRequest( table_names, options ) );
    }

    public async System.Threading.Tasks.Task<ShowWalResponse> ShowWalAsync( IList<string> table_names,
                                                                            IDictionary<string, string> options = null,
                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await ShowWalAsync( new ShowWalRequest( table_names, options ), cancellationToken );
    }

    public SolveGraphResponse solveGraph( SolveGraphRequest request_ )
    {
        SolveGraphResponse actualResponse_ = SubmitRequest<SolveGraphResponse>("/solve/graph", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<SolveGraphResponse> SolveGraphAsync( SolveGraphRequest request_,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        SolveGraphResponse actualResponse_ = await SubmitRequestAsync<SolveGraphResponse>("/solve/graph", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public SolveGraphResponse solveGraph( string graph_name,
                                          IList<string> weights_on_edges = null,
                                          IList<string> restrictions = null,
                                          string solver_type = SolveGraphRequest.SolverType.SHORTEST_PATH,
                                          IList<string> source_nodes = null,
                                          IList<string> destination_nodes = null,
                                          string solution_table = "graph_solutions",
                                          IDictionary<string, string> options = null )
    {
        return solveGraph( new SolveGraphRequest( graph_name, weights_on_edges,
                                                  restrictions, solver_type, source_nodes,
                                                  destination_nodes, solution_table,
                                                  options ) );
    }

    public async System.Threading.Tasks.Task<SolveGraphResponse> SolveGraphAsync( string graph_name,
                                                                                  IList<string> weights_on_edges = null,
                                                                                  IList<string> restrictions = null,
                                                                                  string solver_type = SolveGraphRequest.SolverType.SHORTEST_PATH,
                                                                                  IList<string> source_nodes = null,
                                                                                  IList<string> destination_nodes = null,
                                                                                  string solution_table = "graph_solutions",
                                                                                  IDictionary<string, string> options = null,
                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await SolveGraphAsync( new SolveGraphRequest( graph_name, weights_on_edges,
                                                             restrictions, solver_type,
                                                             source_nodes,
                                                             destination_nodes,
                                                             solution_table, options ), cancellationToken );
    }

    public UpdateRecordsResponse updateRecordsRaw( RawUpdateRecordsRequest request_ )
    {
        UpdateRecordsResponse actualResponse_ = SubmitRequest<UpdateRecordsResponse>("/update/records", request_, true);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<UpdateRecordsResponse> UpdateRecordsRawAsync( RawUpdateRecordsRequest request_,
                                                                                           System.Threading.CancellationToken cancellationToken = default )
    {
        UpdateRecordsResponse actualResponse_ = await SubmitRequestAsync<UpdateRecordsResponse>("/update/records", request_, true, true, cancellationToken);

        return actualResponse_;
    }

    public UpdateRecordsResponse updateRecords<T>( UpdateRecordsRequest<T> request_ )
    {
        RawUpdateRecordsRequest actualRequest_ = new RawUpdateRecordsRequest();
        actualRequest_.table_name = request_.table_name;
        actualRequest_.expressions = request_.expressions;
        actualRequest_.new_values_maps = request_.new_values_maps;
        foreach (var thisObj in request_.data) actualRequest_.records_to_insert.Add( AvroEncode( thisObj ) );
        actualRequest_.options = request_.options;
        UpdateRecordsResponse actualResponse_ = SubmitRequest<UpdateRecordsResponse>("/update/records", actualRequest_, true);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<UpdateRecordsResponse> UpdateRecordsAsync<T>( UpdateRecordsRequest<T> request_,
                                                                                           System.Threading.CancellationToken cancellationToken = default )
    {
        RawUpdateRecordsRequest actualRequest_ = new RawUpdateRecordsRequest();
        actualRequest_.table_name = request_.table_name;
        actualRequest_.expressions = request_.expressions;
        actualRequest_.new_values_maps = request_.new_values_maps;
        foreach (var thisObj in request_.data) actualRequest_.records_to_insert.Add( AvroEncode( thisObj ) );
        actualRequest_.options = request_.options;
        UpdateRecordsResponse actualResponse_ = await SubmitRequestAsync<UpdateRecordsResponse>("/update/records", actualRequest_, true, true, cancellationToken);

        return actualResponse_;
    }

    public UpdateRecordsResponse updateRecords<T>( string table_name,
                                                   IList<string> expressions,
                                                   IList<IDictionary<string, string>> new_values_maps,
                                                   IList<T> data = null,
                                                   IDictionary<string, string> options = null )
    {
        return updateRecords<T>( new UpdateRecordsRequest<T>( table_name, expressions,
                                                              new_values_maps, data,
                                                              options ) );
    }

    public async System.Threading.Tasks.Task<UpdateRecordsResponse> UpdateRecordsAsync<T>( string table_name,
                                                                                           IList<string> expressions,
                                                                                           IList<IDictionary<string, string>> new_values_maps,
                                                                                           IList<T> data = null,
                                                                                           IDictionary<string, string> options = null,
                                                                                           System.Threading.CancellationToken cancellationToken = default )
    {
        return await UpdateRecordsAsync<T>( new UpdateRecordsRequest<T>( table_name,
                                                                         expressions,
                                                                         new_values_maps,
                                                                         data, options ), cancellationToken );
    }

    public UploadFilesResponse uploadFiles( UploadFilesRequest request_ )
    {
        UploadFilesResponse actualResponse_ = SubmitRequest<UploadFilesResponse>("/upload/files", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<UploadFilesResponse> UploadFilesAsync( UploadFilesRequest request_,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        UploadFilesResponse actualResponse_ = await SubmitRequestAsync<UploadFilesResponse>("/upload/files", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public UploadFilesResponse uploadFiles( IList<string> file_names,
                                            IList<byte[]> file_data,
                                            IDictionary<string, string> options = null )
    {
        return uploadFiles( new UploadFilesRequest( file_names, file_data, options ) );
    }

    public async System.Threading.Tasks.Task<UploadFilesResponse> UploadFilesAsync( IList<string> file_names,
                                                                                    IList<byte[]> file_data,
                                                                                    IDictionary<string, string> options = null,
                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await UploadFilesAsync( new UploadFilesRequest( file_names, file_data,
                                                               options ), cancellationToken );
    }

    public UploadFilesFromurlResponse uploadFilesFromurl( UploadFilesFromurlRequest request_ )
    {
        UploadFilesFromurlResponse actualResponse_ = SubmitRequest<UploadFilesFromurlResponse>("/upload/files/fromurl", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<UploadFilesFromurlResponse> UploadFilesFromurlAsync( UploadFilesFromurlRequest request_,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        UploadFilesFromurlResponse actualResponse_ = await SubmitRequestAsync<UploadFilesFromurlResponse>("/upload/files/fromurl", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public UploadFilesFromurlResponse uploadFilesFromurl( IList<string> file_names,
                                                          IList<string> urls,
                                                          IDictionary<string, string> options = null )
    {
        return uploadFilesFromurl( new UploadFilesFromurlRequest( file_names, urls,
                                                                  options ) );
    }

    public async System.Threading.Tasks.Task<UploadFilesFromurlResponse> UploadFilesFromurlAsync( IList<string> file_names,
                                                                                                  IList<string> urls,
                                                                                                  IDictionary<string, string> options = null,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await UploadFilesFromurlAsync( new UploadFilesFromurlRequest( file_names,
                                                                             urls, options ), cancellationToken );
    }

    public VerifyBackupResponse verifyBackup( VerifyBackupRequest request_ )
    {
        VerifyBackupResponse actualResponse_ = SubmitRequest<VerifyBackupResponse>("/verify/backup", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<VerifyBackupResponse> VerifyBackupAsync( VerifyBackupRequest request_,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        VerifyBackupResponse actualResponse_ = await SubmitRequestAsync<VerifyBackupResponse>("/verify/backup", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public VerifyBackupResponse verifyBackup( string backup_name,
                                              string datasource_name,
                                              IDictionary<string, string> options = null )
    {
        return verifyBackup( new VerifyBackupRequest( backup_name, datasource_name,
                                                      options ) );
    }

    public async System.Threading.Tasks.Task<VerifyBackupResponse> VerifyBackupAsync( string backup_name,
                                                                                      string datasource_name,
                                                                                      IDictionary<string, string> options = null,
                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await VerifyBackupAsync( new VerifyBackupRequest( backup_name,
                                                                 datasource_name, options ), cancellationToken );
    }

    public VisualizeGetFeatureInfoResponse visualizeGetFeatureInfo( VisualizeGetFeatureInfoRequest request_ )
    {
        VisualizeGetFeatureInfoResponse actualResponse_ = SubmitRequest<VisualizeGetFeatureInfoResponse>("/visualize/getfeatureinfo", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<VisualizeGetFeatureInfoResponse> VisualizeGetFeatureInfoAsync( VisualizeGetFeatureInfoRequest request_,
                                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        VisualizeGetFeatureInfoResponse actualResponse_ = await SubmitRequestAsync<VisualizeGetFeatureInfoResponse>("/visualize/getfeatureinfo", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public VisualizeGetFeatureInfoResponse visualizeGetFeatureInfo( IList<string> table_names,
                                                                    IList<string> x_column_names,
                                                                    IList<string> y_column_names,
                                                                    IList<string> geometry_column_names,
                                                                    IList<IList<string>> query_column_names,
                                                                    string projection,
                                                                    double min_x,
                                                                    double max_x,
                                                                    double min_y,
                                                                    double max_y,
                                                                    int width,
                                                                    int height,
                                                                    int x,
                                                                    int y,
                                                                    int radius,
                                                                    long limit,
                                                                    string encoding,
                                                                    IDictionary<string, string> options = null )
    {
        return visualizeGetFeatureInfo( new VisualizeGetFeatureInfoRequest( table_names,
                                                                            x_column_names,
                                                                            y_column_names,
                                                                            geometry_column_names,
                                                                            query_column_names,
                                                                            projection,
                                                                            min_x, max_x,
                                                                            min_y, max_y,
                                                                            width, height,
                                                                            x, y, radius,
                                                                            limit,
                                                                            encoding,
                                                                            options ) );
    }

    public async System.Threading.Tasks.Task<VisualizeGetFeatureInfoResponse> VisualizeGetFeatureInfoAsync( IList<string> table_names,
                                                                                                            IList<string> x_column_names,
                                                                                                            IList<string> y_column_names,
                                                                                                            IList<string> geometry_column_names,
                                                                                                            IList<IList<string>> query_column_names,
                                                                                                            string projection,
                                                                                                            double min_x,
                                                                                                            double max_x,
                                                                                                            double min_y,
                                                                                                            double max_y,
                                                                                                            int width,
                                                                                                            int height,
                                                                                                            int x,
                                                                                                            int y,
                                                                                                            int radius,
                                                                                                            long limit,
                                                                                                            string encoding,
                                                                                                            IDictionary<string, string> options = null,
                                                                                                            System.Threading.CancellationToken cancellationToken = default )
    {
        return await VisualizeGetFeatureInfoAsync( new VisualizeGetFeatureInfoRequest( table_names,
                                                                                       x_column_names,
                                                                                       y_column_names,
                                                                                       geometry_column_names,
                                                                                       query_column_names,
                                                                                       projection,
                                                                                       min_x,
                                                                                       max_x,
                                                                                       min_y,
                                                                                       max_y,
                                                                                       width,
                                                                                       height,
                                                                                       x,
                                                                                       y,
                                                                                       radius,
                                                                                       limit,
                                                                                       encoding,
                                                                                       options ), cancellationToken );
    }

    public VisualizeImageResponse visualizeImage( VisualizeImageRequest request_ )
    {
        VisualizeImageResponse actualResponse_ = SubmitRequest<VisualizeImageResponse>("/visualize/image", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<VisualizeImageResponse> VisualizeImageAsync( VisualizeImageRequest request_,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        VisualizeImageResponse actualResponse_ = await SubmitRequestAsync<VisualizeImageResponse>("/visualize/image", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public VisualizeImageResponse visualizeImage( IList<string> table_names,
                                                  IList<string> world_table_names,
                                                  string x_column_name,
                                                  string y_column_name,
                                                  string symbol_column_name,
                                                  string geometry_column_name,
                                                  IList<IList<string>> track_ids,
                                                  double min_x,
                                                  double max_x,
                                                  double min_y,
                                                  double max_y,
                                                  int width,
                                                  int height,
                                                  string projection,
                                                  long bg_color,
                                                  IDictionary<string, IList<string>> style_options,
                                                  IDictionary<string, string> options = null )
    {
        return visualizeImage( new VisualizeImageRequest( table_names, world_table_names,
                                                          x_column_name, y_column_name,
                                                          symbol_column_name,
                                                          geometry_column_name, track_ids,
                                                          min_x, max_x, min_y, max_y,
                                                          width, height, projection,
                                                          bg_color, style_options, options ) );
    }

    public async System.Threading.Tasks.Task<VisualizeImageResponse> VisualizeImageAsync( IList<string> table_names,
                                                                                          IList<string> world_table_names,
                                                                                          string x_column_name,
                                                                                          string y_column_name,
                                                                                          string symbol_column_name,
                                                                                          string geometry_column_name,
                                                                                          IList<IList<string>> track_ids,
                                                                                          double min_x,
                                                                                          double max_x,
                                                                                          double min_y,
                                                                                          double max_y,
                                                                                          int width,
                                                                                          int height,
                                                                                          string projection,
                                                                                          long bg_color,
                                                                                          IDictionary<string, IList<string>> style_options,
                                                                                          IDictionary<string, string> options = null,
                                                                                          System.Threading.CancellationToken cancellationToken = default )
    {
        return await VisualizeImageAsync( new VisualizeImageRequest( table_names,
                                                                     world_table_names,
                                                                     x_column_name,
                                                                     y_column_name,
                                                                     symbol_column_name,
                                                                     geometry_column_name,
                                                                     track_ids, min_x,
                                                                     max_x, min_y, max_y,
                                                                     width, height,
                                                                     projection, bg_color,
                                                                     style_options,
                                                                     options ), cancellationToken );
    }

    public VisualizeImageChartResponse visualizeImageChart( VisualizeImageChartRequest request_ )
    {
        VisualizeImageChartResponse actualResponse_ = SubmitRequest<VisualizeImageChartResponse>("/visualize/image/chart", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<VisualizeImageChartResponse> VisualizeImageChartAsync( VisualizeImageChartRequest request_,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        VisualizeImageChartResponse actualResponse_ = await SubmitRequestAsync<VisualizeImageChartResponse>("/visualize/image/chart", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public VisualizeImageChartResponse visualizeImageChart( string table_name,
                                                            IList<string> x_column_names,
                                                            IList<string> y_column_names,
                                                            double min_x,
                                                            double max_x,
                                                            double min_y,
                                                            double max_y,
                                                            int width,
                                                            int height,
                                                            string bg_color,
                                                            IDictionary<string, IList<string>> style_options,
                                                            IDictionary<string, string> options = null )
    {
        return visualizeImageChart( new VisualizeImageChartRequest( table_name,
                                                                    x_column_names,
                                                                    y_column_names, min_x,
                                                                    max_x, min_y, max_y,
                                                                    width, height,
                                                                    bg_color,
                                                                    style_options, options ) );
    }

    public async System.Threading.Tasks.Task<VisualizeImageChartResponse> VisualizeImageChartAsync( string table_name,
                                                                                                    IList<string> x_column_names,
                                                                                                    IList<string> y_column_names,
                                                                                                    double min_x,
                                                                                                    double max_x,
                                                                                                    double min_y,
                                                                                                    double max_y,
                                                                                                    int width,
                                                                                                    int height,
                                                                                                    string bg_color,
                                                                                                    IDictionary<string, IList<string>> style_options,
                                                                                                    IDictionary<string, string> options = null,
                                                                                                    System.Threading.CancellationToken cancellationToken = default )
    {
        return await VisualizeImageChartAsync( new VisualizeImageChartRequest( table_name,
                                                                               x_column_names,
                                                                               y_column_names,
                                                                               min_x,
                                                                               max_x,
                                                                               min_y,
                                                                               max_y,
                                                                               width,
                                                                               height,
                                                                               bg_color,
                                                                               style_options,
                                                                               options ), cancellationToken );
    }

    public VisualizeImageClassbreakResponse visualizeImageClassbreak( VisualizeImageClassbreakRequest request_ )
    {
        VisualizeImageClassbreakResponse actualResponse_ = SubmitRequest<VisualizeImageClassbreakResponse>("/visualize/image/classbreak", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<VisualizeImageClassbreakResponse> VisualizeImageClassbreakAsync( VisualizeImageClassbreakRequest request_,
                                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        VisualizeImageClassbreakResponse actualResponse_ = await SubmitRequestAsync<VisualizeImageClassbreakResponse>("/visualize/image/classbreak", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public VisualizeImageClassbreakResponse visualizeImageClassbreak( IList<string> table_names,
                                                                      IList<string> world_table_names,
                                                                      string x_column_name,
                                                                      string y_column_name,
                                                                      string symbol_column_name,
                                                                      string geometry_column_name,
                                                                      IList<IList<string>> track_ids,
                                                                      string cb_attr,
                                                                      IList<string> cb_vals,
                                                                      string cb_pointcolor_attr,
                                                                      IList<string> cb_pointcolor_vals,
                                                                      string cb_pointalpha_attr,
                                                                      IList<string> cb_pointalpha_vals,
                                                                      string cb_pointsize_attr,
                                                                      IList<string> cb_pointsize_vals,
                                                                      string cb_pointshape_attr,
                                                                      IList<string> cb_pointshape_vals,
                                                                      double min_x,
                                                                      double max_x,
                                                                      double min_y,
                                                                      double max_y,
                                                                      int width,
                                                                      int height,
                                                                      string projection,
                                                                      long bg_color,
                                                                      IDictionary<string, IList<string>> style_options,
                                                                      IDictionary<string, string> options,
                                                                      IList<int> cb_transparency_vec )
    {
        return visualizeImageClassbreak( new VisualizeImageClassbreakRequest( table_names,
                                                                              world_table_names,
                                                                              x_column_name,
                                                                              y_column_name,
                                                                              symbol_column_name,
                                                                              geometry_column_name,
                                                                              track_ids,
                                                                              cb_attr,
                                                                              cb_vals,
                                                                              cb_pointcolor_attr,
                                                                              cb_pointcolor_vals,
                                                                              cb_pointalpha_attr,
                                                                              cb_pointalpha_vals,
                                                                              cb_pointsize_attr,
                                                                              cb_pointsize_vals,
                                                                              cb_pointshape_attr,
                                                                              cb_pointshape_vals,
                                                                              min_x,
                                                                              max_x,
                                                                              min_y,
                                                                              max_y,
                                                                              width,
                                                                              height,
                                                                              projection,
                                                                              bg_color,
                                                                              style_options,
                                                                              options,
                                                                              cb_transparency_vec ) );
    }

    public async System.Threading.Tasks.Task<VisualizeImageClassbreakResponse> VisualizeImageClassbreakAsync( IList<string> table_names,
                                                                                                              IList<string> world_table_names,
                                                                                                              string x_column_name,
                                                                                                              string y_column_name,
                                                                                                              string symbol_column_name,
                                                                                                              string geometry_column_name,
                                                                                                              IList<IList<string>> track_ids,
                                                                                                              string cb_attr,
                                                                                                              IList<string> cb_vals,
                                                                                                              string cb_pointcolor_attr,
                                                                                                              IList<string> cb_pointcolor_vals,
                                                                                                              string cb_pointalpha_attr,
                                                                                                              IList<string> cb_pointalpha_vals,
                                                                                                              string cb_pointsize_attr,
                                                                                                              IList<string> cb_pointsize_vals,
                                                                                                              string cb_pointshape_attr,
                                                                                                              IList<string> cb_pointshape_vals,
                                                                                                              double min_x,
                                                                                                              double max_x,
                                                                                                              double min_y,
                                                                                                              double max_y,
                                                                                                              int width,
                                                                                                              int height,
                                                                                                              string projection,
                                                                                                              long bg_color,
                                                                                                              IDictionary<string, IList<string>> style_options,
                                                                                                              IDictionary<string, string> options,
                                                                                                              IList<int> cb_transparency_vec,
                                                                                                              System.Threading.CancellationToken cancellationToken = default )
    {
        return await VisualizeImageClassbreakAsync( new VisualizeImageClassbreakRequest( table_names,
                                                                                         world_table_names,
                                                                                         x_column_name,
                                                                                         y_column_name,
                                                                                         symbol_column_name,
                                                                                         geometry_column_name,
                                                                                         track_ids,
                                                                                         cb_attr,
                                                                                         cb_vals,
                                                                                         cb_pointcolor_attr,
                                                                                         cb_pointcolor_vals,
                                                                                         cb_pointalpha_attr,
                                                                                         cb_pointalpha_vals,
                                                                                         cb_pointsize_attr,
                                                                                         cb_pointsize_vals,
                                                                                         cb_pointshape_attr,
                                                                                         cb_pointshape_vals,
                                                                                         min_x,
                                                                                         max_x,
                                                                                         min_y,
                                                                                         max_y,
                                                                                         width,
                                                                                         height,
                                                                                         projection,
                                                                                         bg_color,
                                                                                         style_options,
                                                                                         options,
                                                                                         cb_transparency_vec ), cancellationToken );
    }

    public VisualizeImageContourResponse visualizeImageContour( VisualizeImageContourRequest request_ )
    {
        VisualizeImageContourResponse actualResponse_ = SubmitRequest<VisualizeImageContourResponse>("/visualize/image/contour", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<VisualizeImageContourResponse> VisualizeImageContourAsync( VisualizeImageContourRequest request_,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        VisualizeImageContourResponse actualResponse_ = await SubmitRequestAsync<VisualizeImageContourResponse>("/visualize/image/contour", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public VisualizeImageContourResponse visualizeImageContour( IList<string> table_names,
                                                                string x_column_name,
                                                                string y_column_name,
                                                                string value_column_name,
                                                                double min_x,
                                                                double max_x,
                                                                double min_y,
                                                                double max_y,
                                                                int width,
                                                                int height,
                                                                string projection,
                                                                IDictionary<string, string> style_options,
                                                                IDictionary<string, string> options = null )
    {
        return visualizeImageContour( new VisualizeImageContourRequest( table_names,
                                                                        x_column_name,
                                                                        y_column_name,
                                                                        value_column_name,
                                                                        min_x, max_x,
                                                                        min_y, max_y,
                                                                        width, height,
                                                                        projection,
                                                                        style_options,
                                                                        options ) );
    }

    public async System.Threading.Tasks.Task<VisualizeImageContourResponse> VisualizeImageContourAsync( IList<string> table_names,
                                                                                                        string x_column_name,
                                                                                                        string y_column_name,
                                                                                                        string value_column_name,
                                                                                                        double min_x,
                                                                                                        double max_x,
                                                                                                        double min_y,
                                                                                                        double max_y,
                                                                                                        int width,
                                                                                                        int height,
                                                                                                        string projection,
                                                                                                        IDictionary<string, string> style_options,
                                                                                                        IDictionary<string, string> options = null,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await VisualizeImageContourAsync( new VisualizeImageContourRequest( table_names,
                                                                                   x_column_name,
                                                                                   y_column_name,
                                                                                   value_column_name,
                                                                                   min_x,
                                                                                   max_x,
                                                                                   min_y,
                                                                                   max_y,
                                                                                   width,
                                                                                   height,
                                                                                   projection,
                                                                                   style_options,
                                                                                   options ), cancellationToken );
    }

    public VisualizeImageHeatmapResponse visualizeImageHeatmap( VisualizeImageHeatmapRequest request_ )
    {
        VisualizeImageHeatmapResponse actualResponse_ = SubmitRequest<VisualizeImageHeatmapResponse>("/visualize/image/heatmap", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<VisualizeImageHeatmapResponse> VisualizeImageHeatmapAsync( VisualizeImageHeatmapRequest request_,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        VisualizeImageHeatmapResponse actualResponse_ = await SubmitRequestAsync<VisualizeImageHeatmapResponse>("/visualize/image/heatmap", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public VisualizeImageHeatmapResponse visualizeImageHeatmap( IList<string> table_names,
                                                                string x_column_name,
                                                                string y_column_name,
                                                                string value_column_name,
                                                                string geometry_column_name,
                                                                double min_x,
                                                                double max_x,
                                                                double min_y,
                                                                double max_y,
                                                                int width,
                                                                int height,
                                                                string projection,
                                                                IDictionary<string, string> style_options,
                                                                IDictionary<string, string> options = null )
    {
        return visualizeImageHeatmap( new VisualizeImageHeatmapRequest( table_names,
                                                                        x_column_name,
                                                                        y_column_name,
                                                                        value_column_name,
                                                                        geometry_column_name,
                                                                        min_x, max_x,
                                                                        min_y, max_y,
                                                                        width, height,
                                                                        projection,
                                                                        style_options,
                                                                        options ) );
    }

    public async System.Threading.Tasks.Task<VisualizeImageHeatmapResponse> VisualizeImageHeatmapAsync( IList<string> table_names,
                                                                                                        string x_column_name,
                                                                                                        string y_column_name,
                                                                                                        string value_column_name,
                                                                                                        string geometry_column_name,
                                                                                                        double min_x,
                                                                                                        double max_x,
                                                                                                        double min_y,
                                                                                                        double max_y,
                                                                                                        int width,
                                                                                                        int height,
                                                                                                        string projection,
                                                                                                        IDictionary<string, string> style_options,
                                                                                                        IDictionary<string, string> options = null,
                                                                                                        System.Threading.CancellationToken cancellationToken = default )
    {
        return await VisualizeImageHeatmapAsync( new VisualizeImageHeatmapRequest( table_names,
                                                                                   x_column_name,
                                                                                   y_column_name,
                                                                                   value_column_name,
                                                                                   geometry_column_name,
                                                                                   min_x,
                                                                                   max_x,
                                                                                   min_y,
                                                                                   max_y,
                                                                                   width,
                                                                                   height,
                                                                                   projection,
                                                                                   style_options,
                                                                                   options ), cancellationToken );
    }

    public VisualizeImageLabelsResponse visualizeImageLabels( VisualizeImageLabelsRequest request_ )
    {
        VisualizeImageLabelsResponse actualResponse_ = SubmitRequest<VisualizeImageLabelsResponse>("/visualize/image/labels", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<VisualizeImageLabelsResponse> VisualizeImageLabelsAsync( VisualizeImageLabelsRequest request_,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        VisualizeImageLabelsResponse actualResponse_ = await SubmitRequestAsync<VisualizeImageLabelsResponse>("/visualize/image/labels", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public VisualizeImageLabelsResponse visualizeImageLabels( string table_name,
                                                              string x_column_name,
                                                              string y_column_name,
                                                              string x_offset,
                                                              string y_offset,
                                                              string text_string,
                                                              string font,
                                                              string text_color,
                                                              string text_angle,
                                                              string text_scale,
                                                              string draw_box,
                                                              string draw_leader,
                                                              string line_width,
                                                              string line_color,
                                                              string fill_color,
                                                              string leader_x_column_name,
                                                              string leader_y_column_name,
                                                              string filter,
                                                              double min_x,
                                                              double max_x,
                                                              double min_y,
                                                              double max_y,
                                                              int width,
                                                              int height,
                                                              string projection = VisualizeImageLabelsRequest.Projection.PLATE_CARREE,
                                                              IDictionary<string, string> options = null )
    {
        return visualizeImageLabels( new VisualizeImageLabelsRequest( table_name,
                                                                      x_column_name,
                                                                      y_column_name,
                                                                      x_offset, y_offset,
                                                                      text_string, font,
                                                                      text_color,
                                                                      text_angle,
                                                                      text_scale,
                                                                      draw_box,
                                                                      draw_leader,
                                                                      line_width,
                                                                      line_color,
                                                                      fill_color,
                                                                      leader_x_column_name,
                                                                      leader_y_column_name,
                                                                      filter, min_x,
                                                                      max_x, min_y, max_y,
                                                                      width, height,
                                                                      projection, options ) );
    }

    public async System.Threading.Tasks.Task<VisualizeImageLabelsResponse> VisualizeImageLabelsAsync( string table_name,
                                                                                                      string x_column_name,
                                                                                                      string y_column_name,
                                                                                                      string x_offset,
                                                                                                      string y_offset,
                                                                                                      string text_string,
                                                                                                      string font,
                                                                                                      string text_color,
                                                                                                      string text_angle,
                                                                                                      string text_scale,
                                                                                                      string draw_box,
                                                                                                      string draw_leader,
                                                                                                      string line_width,
                                                                                                      string line_color,
                                                                                                      string fill_color,
                                                                                                      string leader_x_column_name,
                                                                                                      string leader_y_column_name,
                                                                                                      string filter,
                                                                                                      double min_x,
                                                                                                      double max_x,
                                                                                                      double min_y,
                                                                                                      double max_y,
                                                                                                      int width,
                                                                                                      int height,
                                                                                                      string projection = VisualizeImageLabelsRequest.Projection.PLATE_CARREE,
                                                                                                      IDictionary<string, string> options = null,
                                                                                                      System.Threading.CancellationToken cancellationToken = default )
    {
        return await VisualizeImageLabelsAsync( new VisualizeImageLabelsRequest( table_name,
                                                                                 x_column_name,
                                                                                 y_column_name,
                                                                                 x_offset,
                                                                                 y_offset,
                                                                                 text_string,
                                                                                 font,
                                                                                 text_color,
                                                                                 text_angle,
                                                                                 text_scale,
                                                                                 draw_box,
                                                                                 draw_leader,
                                                                                 line_width,
                                                                                 line_color,
                                                                                 fill_color,
                                                                                 leader_x_column_name,
                                                                                 leader_y_column_name,
                                                                                 filter,
                                                                                 min_x,
                                                                                 max_x,
                                                                                 min_y,
                                                                                 max_y,
                                                                                 width,
                                                                                 height,
                                                                                 projection,
                                                                                 options ), cancellationToken );
    }

    public VisualizeIsochroneResponse visualizeIsochrone( VisualizeIsochroneRequest request_ )
    {
        VisualizeIsochroneResponse actualResponse_ = SubmitRequest<VisualizeIsochroneResponse>("/visualize/isochrone", request_, false);

        return actualResponse_;
    }

    public async System.Threading.Tasks.Task<VisualizeIsochroneResponse> VisualizeIsochroneAsync( VisualizeIsochroneRequest request_,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        VisualizeIsochroneResponse actualResponse_ = await SubmitRequestAsync<VisualizeIsochroneResponse>("/visualize/isochrone", request_, false, true, cancellationToken);

        return actualResponse_;
    }

    public VisualizeIsochroneResponse visualizeIsochrone( string graph_name,
                                                          string source_node,
                                                          double max_solution_radius,
                                                          IList<string> weights_on_edges,
                                                          IList<string> restrictions,
                                                          int num_levels,
                                                          bool generate_image,
                                                          string levels_table,
                                                          IDictionary<string, string> style_options,
                                                          IDictionary<string, string> solve_options = null,
                                                          IDictionary<string, string> contour_options = null,
                                                          IDictionary<string, string> options = null )
    {
        return visualizeIsochrone( new VisualizeIsochroneRequest( graph_name, source_node,
                                                                  max_solution_radius,
                                                                  weights_on_edges,
                                                                  restrictions,
                                                                  num_levels,
                                                                  generate_image,
                                                                  levels_table,
                                                                  style_options,
                                                                  solve_options,
                                                                  contour_options, options ) );
    }

    public async System.Threading.Tasks.Task<VisualizeIsochroneResponse> VisualizeIsochroneAsync( string graph_name,
                                                                                                  string source_node,
                                                                                                  double max_solution_radius,
                                                                                                  IList<string> weights_on_edges,
                                                                                                  IList<string> restrictions,
                                                                                                  int num_levels,
                                                                                                  bool generate_image,
                                                                                                  string levels_table,
                                                                                                  IDictionary<string, string> style_options,
                                                                                                  IDictionary<string, string> solve_options = null,
                                                                                                  IDictionary<string, string> contour_options = null,
                                                                                                  IDictionary<string, string> options = null,
                                                                                                  System.Threading.CancellationToken cancellationToken = default )
    {
        return await VisualizeIsochroneAsync( new VisualizeIsochroneRequest( graph_name,
                                                                             source_node,
                                                                             max_solution_radius,
                                                                             weights_on_edges,
                                                                             restrictions,
                                                                             num_levels,
                                                                             generate_image,
                                                                             levels_table,
                                                                             style_options,
                                                                             solve_options,
                                                                             contour_options,
                                                                             options ), cancellationToken );
    }
} // end class Kinetica