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;

namespace kinetica
{
    public partial class Kinetica
    {
        // Kinetica Version
        public const string API_VERSION = "7.2.3.0";

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

            return actualResponse_;
        }

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

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

            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 AdminAlterHostResponse adminAlterHost( AdminAlterHostRequest request_ )
        {
            AdminAlterHostResponse actualResponse_ = SubmitRequest<AdminAlterHostResponse>("/admin/alter/host", request_, false);

            return actualResponse_;
        }

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

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

            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 AdminBackupBeginResponse adminBackupBegin( AdminBackupBeginRequest request_ )
        {
            AdminBackupBeginResponse actualResponse_ = SubmitRequest<AdminBackupBeginResponse>("/admin/backup/begin", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 AdminSendAlertResponse adminSendAlert( AdminSendAlertRequest request_ )
        {
            AdminSendAlertResponse actualResponse_ = SubmitRequest<AdminSendAlertResponse>("/admin/send/alert", request_, false);

            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 AdminShowAlertsResponse adminShowAlerts( AdminShowAlertsRequest request_ )
        {
            AdminShowAlertsResponse actualResponse_ = SubmitRequest<AdminShowAlertsResponse>("/admin/show/alerts", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 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 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 AggregateHistogramResponse aggregateHistogram( AggregateHistogramRequest request_ )
        {
            AggregateHistogramResponse actualResponse_ = SubmitRequest<AggregateHistogramResponse>("/aggregate/histogram", request_, false);

            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 AggregateKMeansResponse aggregateKMeans( AggregateKMeansRequest request_ )
        {
            AggregateKMeansResponse actualResponse_ = SubmitRequest<AggregateKMeansResponse>("/aggregate/kmeans", request_, false);

            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 AggregateMinMaxResponse aggregateMinMax( AggregateMinMaxRequest request_ )
        {
            AggregateMinMaxResponse actualResponse_ = SubmitRequest<AggregateMinMaxResponse>("/aggregate/minmax", request_, false);

            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 AggregateMinMaxGeometryResponse aggregateMinMaxGeometry( AggregateMinMaxGeometryRequest request_ )
        {
            AggregateMinMaxGeometryResponse actualResponse_ = SubmitRequest<AggregateMinMaxGeometryResponse>("/aggregate/minmax/geometry", request_, false);

            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 AggregateStatisticsResponse aggregateStatistics( AggregateStatisticsRequest request_ )
        {
            AggregateStatisticsResponse actualResponse_ = SubmitRequest<AggregateStatisticsResponse>("/aggregate/statistics", request_, false);

            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 AggregateStatisticsByRangeResponse aggregateStatisticsByRange( AggregateStatisticsByRangeRequest request_ )
        {
            AggregateStatisticsByRangeResponse actualResponse_ = SubmitRequest<AggregateStatisticsByRangeResponse>("/aggregate/statistics/byrange", request_, false);

            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 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 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 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 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 AlterBackupResponse alterBackup( AlterBackupRequest request_ )
        {
            AlterBackupResponse actualResponse_ = SubmitRequest<AlterBackupResponse>("/alter/backup", request_, false);

            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 AlterCredentialResponse alterCredential( AlterCredentialRequest request_ )
        {
            AlterCredentialResponse actualResponse_ = SubmitRequest<AlterCredentialResponse>("/alter/credential", request_, false);

            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 AlterDatasinkResponse alterDatasink( AlterDatasinkRequest request_ )
        {
            AlterDatasinkResponse actualResponse_ = SubmitRequest<AlterDatasinkResponse>("/alter/datasink", request_, false);

            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 AlterDatasourceResponse alterDatasource( AlterDatasourceRequest request_ )
        {
            AlterDatasourceResponse actualResponse_ = SubmitRequest<AlterDatasourceResponse>("/alter/datasource", request_, false);

            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 AlterDirectoryResponse alterDirectory( AlterDirectoryRequest request_ )
        {
            AlterDirectoryResponse actualResponse_ = SubmitRequest<AlterDirectoryResponse>("/alter/directory", request_, false);

            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 AlterEnvironmentResponse alterEnvironment( AlterEnvironmentRequest request_ )
        {
            AlterEnvironmentResponse actualResponse_ = SubmitRequest<AlterEnvironmentResponse>("/alter/environment", request_, false);

            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 AlterGraphResponse alterGraph( AlterGraphRequest request_ )
        {
            AlterGraphResponse actualResponse_ = SubmitRequest<AlterGraphResponse>("/alter/graph", request_, false);

            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 AlterModelResponse alterModel( AlterModelRequest request_ )
        {
            AlterModelResponse actualResponse_ = SubmitRequest<AlterModelResponse>("/alter/model", request_, false);

            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 AlterResourceGroupResponse alterResourceGroup( AlterResourceGroupRequest request_ )
        {
            AlterResourceGroupResponse actualResponse_ = SubmitRequest<AlterResourceGroupResponse>("/alter/resourcegroup", request_, false);

            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 AlterRoleResponse alterRole( AlterRoleRequest request_ )
        {
            AlterRoleResponse actualResponse_ = SubmitRequest<AlterRoleResponse>("/alter/role", request_, false);

            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 AlterSchemaResponse alterSchema( AlterSchemaRequest request_ )
        {
            AlterSchemaResponse actualResponse_ = SubmitRequest<AlterSchemaResponse>("/alter/schema", request_, false);

            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 AlterSystemPropertiesResponse alterSystemProperties( AlterSystemPropertiesRequest request_ )
        {
            AlterSystemPropertiesResponse actualResponse_ = SubmitRequest<AlterSystemPropertiesResponse>("/alter/system/properties", request_, false);

            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 AlterTableResponse alterTable( AlterTableRequest request_ )
        {
            AlterTableResponse actualResponse_ = SubmitRequest<AlterTableResponse>("/alter/table", request_, false);

            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 AlterTableColumnsResponse alterTableColumns( AlterTableColumnsRequest request_ )
        {
            AlterTableColumnsResponse actualResponse_ = SubmitRequest<AlterTableColumnsResponse>("/alter/table/columns", request_, false);

            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 AlterTableMetadataResponse alterTableMetadata( AlterTableMetadataRequest request_ )
        {
            AlterTableMetadataResponse actualResponse_ = SubmitRequest<AlterTableMetadataResponse>("/alter/table/metadata", request_, false);

            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 AlterTableMonitorResponse alterTableMonitor( AlterTableMonitorRequest request_ )
        {
            AlterTableMonitorResponse actualResponse_ = SubmitRequest<AlterTableMonitorResponse>("/alter/tablemonitor", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 AlterVideoResponse alterVideo( AlterVideoRequest request_ )
        {
            AlterVideoResponse actualResponse_ = SubmitRequest<AlterVideoResponse>("/alter/video", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 ClearStatisticsResponse clearStatistics( ClearStatisticsRequest request_ )
        {
            ClearStatisticsResponse actualResponse_ = SubmitRequest<ClearStatisticsResponse>("/clear/statistics", request_, false);

            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 ClearTableResponse clearTable( ClearTableRequest request_ )
        {
            ClearTableResponse actualResponse_ = SubmitRequest<ClearTableResponse>("/clear/table", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 CreateBackupResponse createBackup( CreateBackupRequest request_ )
        {
            CreateBackupResponse actualResponse_ = SubmitRequest<CreateBackupResponse>("/create/backup", request_, false);

            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 CreateContainerRegistryResponse createContainerRegistry( CreateContainerRegistryRequest request_ )
        {
            CreateContainerRegistryResponse actualResponse_ = SubmitRequest<CreateContainerRegistryResponse>("/create/container/registry", request_, false);

            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 CreateCredentialResponse createCredential( CreateCredentialRequest request_ )
        {
            CreateCredentialResponse actualResponse_ = SubmitRequest<CreateCredentialResponse>("/create/credential", request_, false);

            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 CreateDatasinkResponse createDatasink( CreateDatasinkRequest request_ )
        {
            CreateDatasinkResponse actualResponse_ = SubmitRequest<CreateDatasinkResponse>("/create/datasink", request_, false);

            return actualResponse_;
        }

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

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

            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 CreateDeltaTableResponse createDeltaTable( CreateDeltaTableRequest request_ )
        {
            CreateDeltaTableResponse actualResponse_ = SubmitRequest<CreateDeltaTableResponse>("/create/deltatable", request_, false);

            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 CreateDirectoryResponse createDirectory( CreateDirectoryRequest request_ )
        {
            CreateDirectoryResponse actualResponse_ = SubmitRequest<CreateDirectoryResponse>("/create/directory", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 CreateJobResponse createJob( CreateJobRequest request_ )
        {
            CreateJobResponse actualResponse_ = SubmitRequest<CreateJobResponse>("/create/job", request_, false);

            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 CreateJoinTableResponse createJoinTable( CreateJoinTableRequest request_ )
        {
            CreateJoinTableResponse actualResponse_ = SubmitRequest<CreateJoinTableResponse>("/create/jointable", request_, false);

            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 CreateMaterializedViewResponse createMaterializedView( CreateMaterializedViewRequest request_ )
        {
            CreateMaterializedViewResponse actualResponse_ = SubmitRequest<CreateMaterializedViewResponse>("/create/materializedview", request_, false);

            return actualResponse_;
        }

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

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

            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 CreateProjectionResponse createProjection( CreateProjectionRequest request_ )
        {
            CreateProjectionResponse actualResponse_ = SubmitRequest<CreateProjectionResponse>("/create/projection", request_, false);

            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 CreateResourceGroupResponse createResourceGroup( CreateResourceGroupRequest request_ )
        {
            CreateResourceGroupResponse actualResponse_ = SubmitRequest<CreateResourceGroupResponse>("/create/resourcegroup", request_, false);

            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 CreateRoleResponse createRole( CreateRoleRequest request_ )
        {
            CreateRoleResponse actualResponse_ = SubmitRequest<CreateRoleResponse>("/create/role", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 CreateTableResponse createTable( CreateTableRequest request_ )
        {
            CreateTableResponse actualResponse_ = SubmitRequest<CreateTableResponse>("/create/table", request_, false);

            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 CreateTableExternalResponse createTableExternal( CreateTableExternalRequest request_ )
        {
            CreateTableExternalResponse actualResponse_ = SubmitRequest<CreateTableExternalResponse>("/create/table/external", request_, false);

            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 CreateTableMonitorResponse createTableMonitor( CreateTableMonitorRequest request_ )
        {
            CreateTableMonitorResponse actualResponse_ = SubmitRequest<CreateTableMonitorResponse>("/create/tablemonitor", request_, false);

            return actualResponse_;
        }

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

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

            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 CreateTriggerByRangeResponse createTriggerByRange( CreateTriggerByRangeRequest request_ )
        {
            CreateTriggerByRangeResponse actualResponse_ = SubmitRequest<CreateTriggerByRangeResponse>("/create/trigger/byrange", request_, false);

            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 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 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 CreateUnionResponse createUnion( CreateUnionRequest request_ )
        {
            CreateUnionResponse actualResponse_ = SubmitRequest<CreateUnionResponse>("/create/union", request_, false);

            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 CreateUserExternalResponse createUserExternal( CreateUserExternalRequest request_ )
        {
            CreateUserExternalResponse actualResponse_ = SubmitRequest<CreateUserExternalResponse>("/create/user/external", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 DeleteDirectoryResponse deleteDirectory( DeleteDirectoryRequest request_ )
        {
            DeleteDirectoryResponse actualResponse_ = SubmitRequest<DeleteDirectoryResponse>("/delete/directory", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 DeleteResourceGroupResponse deleteResourceGroup( DeleteResourceGroupRequest request_ )
        {
            DeleteResourceGroupResponse actualResponse_ = SubmitRequest<DeleteResourceGroupResponse>("/delete/resourcegroup", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 DropBackupResponse dropBackup( DropBackupRequest request_ )
        {
            DropBackupResponse actualResponse_ = SubmitRequest<DropBackupResponse>("/drop/backup", request_, false);

            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 DropContainerRegistryResponse dropContainerRegistry( DropContainerRegistryRequest request_ )
        {
            DropContainerRegistryResponse actualResponse_ = SubmitRequest<DropContainerRegistryResponse>("/drop/container/registry", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 ExecuteProcResponse executeProc( ExecuteProcRequest request_ )
        {
            ExecuteProcResponse actualResponse_ = SubmitRequest<ExecuteProcResponse>("/execute/proc", request_, false);

            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 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 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 ExportQueryMetricsResponse exportQueryMetrics( ExportQueryMetricsRequest request_ )
        {
            ExportQueryMetricsResponse actualResponse_ = SubmitRequest<ExportQueryMetricsResponse>("/export/query/metrics", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 FilterResponse filter( FilterRequest request_ )
        {
            FilterResponse actualResponse_ = SubmitRequest<FilterResponse>("/filter", request_, false);

            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 FilterByAreaResponse filterByArea( FilterByAreaRequest request_ )
        {
            FilterByAreaResponse actualResponse_ = SubmitRequest<FilterByAreaResponse>("/filter/byarea", request_, false);

            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 FilterByAreaGeometryResponse filterByAreaGeometry( FilterByAreaGeometryRequest request_ )
        {
            FilterByAreaGeometryResponse actualResponse_ = SubmitRequest<FilterByAreaGeometryResponse>("/filter/byarea/geometry", request_, false);

            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 FilterByBoxResponse filterByBox( FilterByBoxRequest request_ )
        {
            FilterByBoxResponse actualResponse_ = SubmitRequest<FilterByBoxResponse>("/filter/bybox", request_, false);

            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 FilterByBoxGeometryResponse filterByBoxGeometry( FilterByBoxGeometryRequest request_ )
        {
            FilterByBoxGeometryResponse actualResponse_ = SubmitRequest<FilterByBoxGeometryResponse>("/filter/bybox/geometry", request_, false);

            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 FilterByGeometryResponse filterByGeometry( FilterByGeometryRequest request_ )
        {
            FilterByGeometryResponse actualResponse_ = SubmitRequest<FilterByGeometryResponse>("/filter/bygeometry", request_, false);

            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 FilterByListResponse filterByList( FilterByListRequest request_ )
        {
            FilterByListResponse actualResponse_ = SubmitRequest<FilterByListResponse>("/filter/bylist", request_, false);

            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 FilterByRadiusResponse filterByRadius( FilterByRadiusRequest request_ )
        {
            FilterByRadiusResponse actualResponse_ = SubmitRequest<FilterByRadiusResponse>("/filter/byradius", request_, false);

            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 FilterByRadiusGeometryResponse filterByRadiusGeometry( FilterByRadiusGeometryRequest request_ )
        {
            FilterByRadiusGeometryResponse actualResponse_ = SubmitRequest<FilterByRadiusGeometryResponse>("/filter/byradius/geometry", request_, false);

            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 FilterByRangeResponse filterByRange( FilterByRangeRequest request_ )
        {
            FilterByRangeResponse actualResponse_ = SubmitRequest<FilterByRangeResponse>("/filter/byrange", request_, false);

            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 FilterBySeriesResponse filterBySeries( FilterBySeriesRequest request_ )
        {
            FilterBySeriesResponse actualResponse_ = SubmitRequest<FilterBySeriesResponse>("/filter/byseries", request_, false);

            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 FilterByStringResponse filterByString( FilterByStringRequest request_ )
        {
            FilterByStringResponse actualResponse_ = SubmitRequest<FilterByStringResponse>("/filter/bystring", request_, false);

            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 FilterByTableResponse filterByTable( FilterByTableRequest request_ )
        {
            FilterByTableResponse actualResponse_ = SubmitRequest<FilterByTableResponse>("/filter/bytable", request_, false);

            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 FilterByValueResponse filterByValue( FilterByValueRequest request_ )
        {
            FilterByValueResponse actualResponse_ = SubmitRequest<FilterByValueResponse>("/filter/byvalue", request_, false);

            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 GetJobResponse getJob( GetJobRequest request_ )
        {
            GetJobResponse actualResponse_ = SubmitRequest<GetJobResponse>("/get/job", request_, false);

            return actualResponse_;
        }

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

        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 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 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 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 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 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 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 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 GetVectortileResponse getVectortile( GetVectortileRequest request_ )
        {
            GetVectortileResponse actualResponse_ = SubmitRequest<GetVectortileResponse>("/get/vectortile", request_, false);

            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 GrantPermissionResponse grantPermission( GrantPermissionRequest request_ )
        {
            GrantPermissionResponse actualResponse_ = SubmitRequest<GrantPermissionResponse>("/grant/permission", request_, false);

            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 GrantPermissionCredentialResponse grantPermissionCredential( GrantPermissionCredentialRequest request_ )
        {
            GrantPermissionCredentialResponse actualResponse_ = SubmitRequest<GrantPermissionCredentialResponse>("/grant/permission/credential", request_, false);

            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 GrantPermissionDatasourceResponse grantPermissionDatasource( GrantPermissionDatasourceRequest request_ )
        {
            GrantPermissionDatasourceResponse actualResponse_ = SubmitRequest<GrantPermissionDatasourceResponse>("/grant/permission/datasource", request_, false);

            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 GrantPermissionDirectoryResponse grantPermissionDirectory( GrantPermissionDirectoryRequest request_ )
        {
            GrantPermissionDirectoryResponse actualResponse_ = SubmitRequest<GrantPermissionDirectoryResponse>("/grant/permission/directory", request_, false);

            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 GrantPermissionProcResponse grantPermissionProc( GrantPermissionProcRequest request_ )
        {
            GrantPermissionProcResponse actualResponse_ = SubmitRequest<GrantPermissionProcResponse>("/grant/permission/proc", request_, false);

            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 GrantPermissionSystemResponse grantPermissionSystem( GrantPermissionSystemRequest request_ )
        {
            GrantPermissionSystemResponse actualResponse_ = SubmitRequest<GrantPermissionSystemResponse>("/grant/permission/system", request_, false);

            return actualResponse_;
        }

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

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

            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 GrantRoleResponse grantRole( GrantRoleRequest request_ )
        {
            GrantRoleResponse actualResponse_ = SubmitRequest<GrantRoleResponse>("/grant/role", request_, false);

            return actualResponse_;
        }

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

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

            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 HasProcResponse hasProc( HasProcRequest request_ )
        {
            HasProcResponse actualResponse_ = SubmitRequest<HasProcResponse>("/has/proc", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 InsertRecordsResponse insertRecordsRaw( RawInsertRecordsRequest request_ )
        {
            InsertRecordsResponse actualResponse_ = SubmitRequest<InsertRecordsResponse>("/insert/records", request_, true);

            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 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 InsertRecordsFromFilesResponse insertRecordsFromFiles( InsertRecordsFromFilesRequest request_ )
        {
            InsertRecordsFromFilesResponse actualResponse_ = SubmitRequest<InsertRecordsFromFilesResponse>("/insert/records/fromfiles", request_, false);

            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 InsertRecordsFromPayloadResponse insertRecordsFromPayload( InsertRecordsFromPayloadRequest request_ )
        {
            InsertRecordsFromPayloadResponse actualResponse_ = SubmitRequest<InsertRecordsFromPayloadResponse>("/insert/records/frompayload", request_, false);

            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 InsertRecordsFromQueryResponse insertRecordsFromQuery( InsertRecordsFromQueryRequest request_ )
        {
            InsertRecordsFromQueryResponse actualResponse_ = SubmitRequest<InsertRecordsFromQueryResponse>("/insert/records/fromquery", request_, false);

            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 InsertRecordsRandomResponse insertRecordsRandom( InsertRecordsRandomRequest request_ )
        {
            InsertRecordsRandomResponse actualResponse_ = SubmitRequest<InsertRecordsRandomResponse>("/insert/records/random", request_, false);

            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 InsertSymbolResponse insertSymbol( InsertSymbolRequest request_ )
        {
            InsertSymbolResponse actualResponse_ = SubmitRequest<InsertSymbolResponse>("/insert/symbol", request_, false);

            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 KillProcResponse killProc( KillProcRequest request_ )
        {
            KillProcResponse actualResponse_ = SubmitRequest<KillProcResponse>("/kill/proc", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            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 MatchGraphResponse matchGraph( MatchGraphRequest request_ )
        {
            MatchGraphResponse actualResponse_ = SubmitRequest<MatchGraphResponse>("/match/graph", request_, false);

            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 ModifyGraphResponse modifyGraph( ModifyGraphRequest request_ )
        {
            ModifyGraphResponse actualResponse_ = SubmitRequest<ModifyGraphResponse>("/modify/graph", request_, false);

            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 QueryGraphResponse queryGraph( QueryGraphRequest request_ )
        {
            QueryGraphResponse actualResponse_ = SubmitRequest<QueryGraphResponse>("/query/graph", request_, false);

            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 RepartitionGraphResponse repartitionGraph( RepartitionGraphRequest request_ )
        {
            RepartitionGraphResponse actualResponse_ = SubmitRequest<RepartitionGraphResponse>("/repartition/graph", request_, false);

            return actualResponse_;
        }

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

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

            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 RestoreBackupResponse restoreBackup( RestoreBackupRequest request_ )
        {
            RestoreBackupResponse actualResponse_ = SubmitRequest<RestoreBackupResponse>("/restore/backup", request_, false);

            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 RevokePermissionResponse revokePermission( RevokePermissionRequest request_ )
        {
            RevokePermissionResponse actualResponse_ = SubmitRequest<RevokePermissionResponse>("/revoke/permission", request_, false);

            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 RevokePermissionCredentialResponse revokePermissionCredential( RevokePermissionCredentialRequest request_ )
        {
            RevokePermissionCredentialResponse actualResponse_ = SubmitRequest<RevokePermissionCredentialResponse>("/revoke/permission/credential", request_, false);

            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 RevokePermissionDatasourceResponse revokePermissionDatasource( RevokePermissionDatasourceRequest request_ )
        {
            RevokePermissionDatasourceResponse actualResponse_ = SubmitRequest<RevokePermissionDatasourceResponse>("/revoke/permission/datasource", request_, false);

            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 RevokePermissionDirectoryResponse revokePermissionDirectory( RevokePermissionDirectoryRequest request_ )
        {
            RevokePermissionDirectoryResponse actualResponse_ = SubmitRequest<RevokePermissionDirectoryResponse>("/revoke/permission/directory", request_, false);

            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 RevokePermissionProcResponse revokePermissionProc( RevokePermissionProcRequest request_ )
        {
            RevokePermissionProcResponse actualResponse_ = SubmitRequest<RevokePermissionProcResponse>("/revoke/permission/proc", request_, false);

            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 RevokePermissionSystemResponse revokePermissionSystem( RevokePermissionSystemRequest request_ )
        {
            RevokePermissionSystemResponse actualResponse_ = SubmitRequest<RevokePermissionSystemResponse>("/revoke/permission/system", request_, false);

            return actualResponse_;
        }

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

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

            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 RevokeRoleResponse revokeRole( RevokeRoleRequest request_ )
        {
            RevokeRoleResponse actualResponse_ = SubmitRequest<RevokeRoleResponse>("/revoke/role", request_, false);

            return actualResponse_;
        }

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

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

            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 ShowContainerRegistryResponse showContainerRegistry( ShowContainerRegistryRequest request_ )
        {
            ShowContainerRegistryResponse actualResponse_ = SubmitRequest<ShowContainerRegistryResponse>("/show/container/registry", request_, false);

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

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

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

            return actualResponse_;
        }

        public ShowSystemTimingResponse showSystemTiming( IDictionary<string, string> options = null )
        {
            return showSystemTiming( new ShowSystemTimingRequest( options ) );
        }

        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 ShowTableResponse showTable( string table_name,
                                            IDictionary<string, string> options = null )
        {
            return showTable( new ShowTableRequest( table_name, options ) );
        }

        public ShowTableMetadataResponse showTableMetadata( ShowTableMetadataRequest request_ )
        {
            ShowTableMetadataResponse actualResponse_ = SubmitRequest<ShowTableMetadataResponse>("/show/table/metadata", request_, false);

            return actualResponse_;
        }

        public ShowTableMetadataResponse showTableMetadata( IList<string> table_names,
                                                            IDictionary<string, string> options = null )
        {
            return showTableMetadata( new ShowTableMetadataRequest( table_names, options ) );
        }

        public ShowTableMonitorsResponse showTableMonitors( ShowTableMonitorsRequest request_ )
        {
            ShowTableMonitorsResponse actualResponse_ = SubmitRequest<ShowTableMonitorsResponse>("/show/tablemonitors", request_, false);

            return actualResponse_;
        }

        public ShowTableMonitorsResponse showTableMonitors( IList<string> monitor_ids,
                                                            IDictionary<string, string> options = null )
        {
            return showTableMonitors( new ShowTableMonitorsRequest( monitor_ids, options ) );
        }

        public ShowTablesByTypeResponse showTablesByType( ShowTablesByTypeRequest request_ )
        {
            ShowTablesByTypeResponse actualResponse_ = SubmitRequest<ShowTablesByTypeResponse>("/show/tables/bytype", request_, false);

            return actualResponse_;
        }

        public ShowTablesByTypeResponse showTablesByType( string type_id,
                                                          string label,
                                                          IDictionary<string, string> options = null )
        {
            return showTablesByType( new ShowTablesByTypeRequest( type_id, label, options ) );
        }

        public ShowTriggersResponse showTriggers( ShowTriggersRequest request_ )
        {
            ShowTriggersResponse actualResponse_ = SubmitRequest<ShowTriggersResponse>("/show/triggers", request_, false);

            return actualResponse_;
        }

        public ShowTriggersResponse showTriggers( IList<string> trigger_ids,
                                                  IDictionary<string, string> options = null )
        {
            return showTriggers( new ShowTriggersRequest( trigger_ids, options ) );
        }

        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 ShowTypesResponse showTypes( string type_id,
                                            string label,
                                            IDictionary<string, string> options = null )
        {
            return showTypes( new ShowTypesRequest( type_id, label, options ) );
        }

        public ShowVideoResponse showVideo( ShowVideoRequest request_ )
        {
            ShowVideoResponse actualResponse_ = SubmitRequest<ShowVideoResponse>("/show/video", request_, false);

            return actualResponse_;
        }

        public ShowVideoResponse showVideo( IList<string> paths,
                                            IDictionary<string, string> options = null )
        {
            return showVideo( new ShowVideoRequest( paths, options ) );
        }

        public ShowWalResponse showWal( ShowWalRequest request_ )
        {
            ShowWalResponse actualResponse_ = SubmitRequest<ShowWalResponse>("/show/wal", request_, false);

            return actualResponse_;
        }

        public ShowWalResponse showWal( IList<string> table_names,
                                        IDictionary<string, string> options = null )
        {
            return showWal( new ShowWalRequest( table_names, options ) );
        }

        public SolveGraphResponse solveGraph( SolveGraphRequest request_ )
        {
            SolveGraphResponse actualResponse_ = SubmitRequest<SolveGraphResponse>("/solve/graph", request_, false);

            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 UpdateRecordsResponse updateRecordsRaw( RawUpdateRecordsRequest request_ )
        {
            UpdateRecordsResponse actualResponse_ = SubmitRequest<UpdateRecordsResponse>("/update/records", request_, true);

            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 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 UpdateRecordsBySeriesResponse updateRecordsBySeries( UpdateRecordsBySeriesRequest request_ )
        {
            UpdateRecordsBySeriesResponse actualResponse_ = SubmitRequest<UpdateRecordsBySeriesResponse>("/update/records/byseries", request_, false);

            return actualResponse_;
        }

        public UpdateRecordsBySeriesResponse updateRecordsBySeries( string table_name,
                                                                    string world_table_name,
                                                                    string view_name = "",
                                                                    IList<string> reserved = null,
                                                                    IDictionary<string, string> options = null )
        {
            return updateRecordsBySeries( new UpdateRecordsBySeriesRequest( table_name,
                                                                            world_table_name,
                                                                            view_name,
                                                                            reserved,
                                                                            options ) );
        }

        public UploadFilesResponse uploadFiles( UploadFilesRequest request_ )
        {
            UploadFilesResponse actualResponse_ = SubmitRequest<UploadFilesResponse>("/upload/files", request_, false);

            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 UploadFilesFromurlResponse uploadFilesFromurl( UploadFilesFromurlRequest request_ )
        {
            UploadFilesFromurlResponse actualResponse_ = SubmitRequest<UploadFilesFromurlResponse>("/upload/files/fromurl", request_, false);

            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 VisualizeGetFeatureInfoResponse visualizeGetFeatureInfo( VisualizeGetFeatureInfoRequest request_ )
        {
            VisualizeGetFeatureInfoResponse actualResponse_ = SubmitRequest<VisualizeGetFeatureInfoResponse>("/visualize/getfeatureinfo", request_, false);

            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 VisualizeImageResponse visualizeImage( VisualizeImageRequest request_ )
        {
            VisualizeImageResponse actualResponse_ = SubmitRequest<VisualizeImageResponse>("/visualize/image", request_, false);

            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 VisualizeImageChartResponse visualizeImageChart( VisualizeImageChartRequest request_ )
        {
            VisualizeImageChartResponse actualResponse_ = SubmitRequest<VisualizeImageChartResponse>("/visualize/image/chart", request_, false);

            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 VisualizeImageClassbreakResponse visualizeImageClassbreak( VisualizeImageClassbreakRequest request_ )
        {
            VisualizeImageClassbreakResponse actualResponse_ = SubmitRequest<VisualizeImageClassbreakResponse>("/visualize/image/classbreak", request_, false);

            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 VisualizeImageContourResponse visualizeImageContour( VisualizeImageContourRequest request_ )
        {
            VisualizeImageContourResponse actualResponse_ = SubmitRequest<VisualizeImageContourResponse>("/visualize/image/contour", request_, false);

            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 VisualizeImageHeatmapResponse visualizeImageHeatmap( VisualizeImageHeatmapRequest request_ )
        {
            VisualizeImageHeatmapResponse actualResponse_ = SubmitRequest<VisualizeImageHeatmapResponse>("/visualize/image/heatmap", request_, false);

            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 VisualizeImageLabelsResponse visualizeImageLabels( VisualizeImageLabelsRequest request_ )
        {
            VisualizeImageLabelsResponse actualResponse_ = SubmitRequest<VisualizeImageLabelsResponse>("/visualize/image/labels", request_, false);

            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 VisualizeIsochroneResponse visualizeIsochrone( VisualizeIsochroneRequest request_ )
        {
            VisualizeIsochroneResponse actualResponse_ = SubmitRequest<VisualizeIsochroneResponse>("/visualize/isochrone", request_, false);

            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 ) );
        }
    } // end class Kinetica
} // end namespace kinetica