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 = "6.0.1.0";



        public AdminDeleteNodeResponse adminDeleteNode( AdminDeleteNodeRequest request_ )
        {
            AdminDeleteNodeResponse actualResponse_ = SubmitRequest<AdminDeleteNodeResponse>("/admin/delete/node", request_, false);

            return actualResponse_;
        }


        public AdminDeleteNodeResponse adminDeleteNode( int rank,
                                                        string authorization,
                                                        IDictionary<string, string> options = null )
        {
            return adminDeleteNode( new AdminDeleteNodeRequest( rank, authorization,
                                                                options ) );
        }


        public AdminGetShardAssignmentsResponse adminGetShardAssignments( AdminGetShardAssignmentsRequest request_ )
        {
            AdminGetShardAssignmentsResponse actualResponse_ = SubmitRequest<AdminGetShardAssignmentsResponse>("/admin/getshardassignments", request_, false);

            return actualResponse_;
        }


        public AdminGetShardAssignmentsResponse adminGetShardAssignments( IDictionary<string, string> options = null )
        {
            return adminGetShardAssignments( new AdminGetShardAssignmentsRequest( 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( IList<string> table_names,
                                                      IDictionary<string, string> options = null )
        {
            return adminRebalance( new AdminRebalanceRequest( table_names, options ) );
        }


        public AdminSetShardAssignmentsResponse adminSetShardAssignments( AdminSetShardAssignmentsRequest request_ )
        {
            AdminSetShardAssignmentsResponse actualResponse_ = SubmitRequest<AdminSetShardAssignmentsResponse>("/admin/setshardassignments", request_, false);

            return actualResponse_;
        }


        public AdminSetShardAssignmentsResponse adminSetShardAssignments( long version,
                                                                          bool partial_reassignment,
                                                                          IList<int> shard_assignments_rank,
                                                                          IList<int> shard_assignments_tom,
                                                                          IList<int> assignment_index,
                                                                          IDictionary<string, string> options = null )
        {
            return adminSetShardAssignments( new AdminSetShardAssignmentsRequest( version,
                                                                                  partial_reassignment,
                                                                                  shard_assignments_rank,
                                                                                  shard_assignments_tom,
                                                                                  assignment_index,
                                                                                  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 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;
            return response_;
        }


        public AggregateGroupByResponse aggregateGroupBy( string table_name,
                                                          IList<string> column_names,
                                                          long offset,
                                                          long limit = 1000,
                                                          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 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;
            return response_;
        }


        public AggregateUniqueResponse aggregateUnique( string table_name,
                                                        string column_name,
                                                        long offset,
                                                        long limit = 10000,
                                                        IDictionary<string, string> options = null )
        {
            return aggregateUnique( new AggregateUniqueRequest( table_name, column_name,
                                                                offset, limit, 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 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 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 )
        {
            return alterUser( new AlterUserRequest( name, action, _value, 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 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 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 = null,
                                                        IList<string> column_names = null,
                                                        IList<string> expressions = null,
                                                        IDictionary<string, string> options = null )
        {
            return createJoinTable( new CreateJoinTableRequest( join_table_name,
                                                                table_names, column_names,
                                                                expressions, 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 CreateRoleResponse createRole( CreateRoleRequest request_ )
        {
            CreateRoleResponse actualResponse_ = SubmitRequest<CreateRoleResponse>("/create/role", request_, false);

            return actualResponse_;
        }


        public CreateRoleResponse createRole( string name,
                                              IDictionary<string, string> options )
        {
            return createRole( new CreateRoleRequest( 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 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 )
        {
            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 )
        {
            return createUserInternal( new CreateUserInternalRequest( name, password,
                                                                      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 DeleteRoleResponse deleteRole( DeleteRoleRequest request_ )
        {
            DeleteRoleResponse actualResponse_ = SubmitRequest<DeleteRoleResponse>("/delete/role", request_, false);

            return actualResponse_;
        }


        public DeleteRoleResponse deleteRole( string name,
                                              IDictionary<string, string> options )
        {
            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 )
        {
            return deleteUser( new DeleteUserRequest( name, 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 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 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 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 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 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;
            return response_;
        }


        public GetRecordsResponse<T> getRecords<T>( string table_name,
                                                    long offset = 0,
                                                    long limit = 10000,
                                                    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;
            return response_;
        }


        public GetRecordsByColumnResponse getRecordsByColumn( string table_name,
                                                              IList<string> column_names,
                                                              long offset,
                                                              long limit,
                                                              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 );
            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;
            return response_;
        }


        public GetRecordsFromCollectionResponse<T> getRecordsFromCollection<T>( string table_name,
                                                                                long offset = 0,
                                                                                long limit = 10000,
                                                                                IDictionary<string, string> options = null ) where T : new()
        {
            return getRecordsFromCollection<T>( new GetRecordsFromCollectionRequest(
                                                                                     table_name,
                                                                                     offset,
                                                                                     limit,
                                                                                     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 )
        {
            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 )
        {
            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 )
        {
            return grantRole( new GrantRoleRequest( role, member, 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 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 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 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 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 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 )
        {
            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 )
        {
            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 )
        {
            return revokeRole( new RevokeRoleRequest( role, member, 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 ShowSecurityResponse showSecurity( ShowSecurityRequest request_ )
        {
            ShowSecurityResponse actualResponse_ = SubmitRequest<ShowSecurityResponse>("/show/security", request_, false);

            return actualResponse_;
        }


        public ShowSecurityResponse showSecurity( IList<string> names,
                                                  IDictionary<string, string> options )
        {
            return showSecurity( new ShowSecurityRequest( 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 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 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 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,
                                                      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, track_ids,
                                                              min_x, max_x, min_y, max_y,
                                                              width, height, projection,
                                                              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,
                                                                          IList<IList<string>> track_ids,
                                                                          string cb_column_name1,
                                                                          IList<string> cb_vals1,
                                                                          IList<string> cb_column_name2,
                                                                          IList<IList<string>> cb_vals2,
                                                                          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 visualizeImageClassbreak( new VisualizeImageClassbreakRequest(
                                                                                  table_names,
                                                                                  world_table_names,
                                                                                  x_column_name,
                                                                                  y_column_name,
                                                                                  track_ids,
                                                                                  cb_column_name1,
                                                                                  cb_vals1,
                                                                                  cb_column_name2,
                                                                                  cb_vals2,
                                                                                  min_x,
                                                                                  max_x,
                                                                                  min_y,
                                                                                  max_y,
                                                                                  width,
                                                                                  height,
                                                                                  projection,
                                                                                  bg_color,
                                                                                  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,
                                                                    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,
                                                                            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,
                                                                  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,
                                                                          min_x, max_x,
                                                                          min_y, max_y,
                                                                          width, height,
                                                                          projection,
                                                                          options ) );
        }


        public VisualizeVideoResponse visualizeVideo( VisualizeVideoRequest request_ )
        {
            VisualizeVideoResponse actualResponse_ = SubmitRequest<VisualizeVideoResponse>("/visualize/video", request_, false);

            return actualResponse_;
        }


        public VisualizeVideoResponse visualizeVideo( IList<string> table_names,
                                                      IList<string> world_table_names,
                                                      IList<IList<string>> track_ids,
                                                      string x_column_name,
                                                      string y_column_name,
                                                      double min_x,
                                                      double max_x,
                                                      double min_y,
                                                      double max_y,
                                                      int width,
                                                      int height,
                                                      string projection,
                                                      long bg_color,
                                                      IList<IList<double>> time_intervals,
                                                      string video_style,
                                                      string session_key,
                                                      IDictionary<string, IList<string>> style_options,
                                                      IDictionary<string, string> options = null )
        {
            return visualizeVideo( new VisualizeVideoRequest( table_names,
                                                              world_table_names,
                                                              track_ids, x_column_name,
                                                              y_column_name, min_x, max_x,
                                                              min_y, max_y, width, height,
                                                              projection, bg_color,
                                                              time_intervals, video_style,
                                                              session_key, style_options,
                                                              options ) );
        }


        public VisualizeVideoHeatmapResponse visualizeVideoHeatmap( VisualizeVideoHeatmapRequest request_ )
        {
            VisualizeVideoHeatmapResponse actualResponse_ = SubmitRequest<VisualizeVideoHeatmapResponse>("/visualize/video/heatmap", request_, false);

            return actualResponse_;
        }


        public VisualizeVideoHeatmapResponse visualizeVideoHeatmap( IList<string> table_names,
                                                                    string x_column_name,
                                                                    string y_column_name,
                                                                    double min_x,
                                                                    double max_x,
                                                                    double min_y,
                                                                    double max_y,
                                                                    IList<IList<double>> time_intervals,
                                                                    int width,
                                                                    int height,
                                                                    string projection,
                                                                    string video_style,
                                                                    string session_key,
                                                                    IDictionary<string, string> style_options,
                                                                    IDictionary<string, string> options = null )
        {
            return visualizeVideoHeatmap( new VisualizeVideoHeatmapRequest( table_names,
                                                                            x_column_name,
                                                                            y_column_name,
                                                                            min_x, max_x,
                                                                            min_y, max_y,
                                                                            time_intervals,
                                                                            width, height,
                                                                            projection,
                                                                            video_style,
                                                                            session_key,
                                                                            style_options,
                                                                            options ) );
        }


    }  // end class Kinetica
}  // end namespace kinetica