import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExecutableReportAPIApi;

import java.io.File;
import java.util.*;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseVoid result = apiInstance.deleteByUuid2(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#deleteByUuid2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ExecutableReportAPIApi;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseVoid result = apiInstance.deleteByUuid2(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#deleteByUuid2");
            e.printStackTrace();
        }
    }
}

String *uuid = uuid_example; // 

ExecutableReportAPIApi *apiInstance = [[ExecutableReportAPIApi alloc] init];

// Deletes executable report with provided uuid
[apiInstance deleteByUuid2With:uuid
              completionHandler: ^(HvlResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ExecutableReportAPIApi()
var uuid = uuid_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteByUuid2(uuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteByUuid2Example
    {
        public void main()
        {

            var apiInstance = new ExecutableReportAPIApi();
            var uuid = uuid_example;  // String | 

            try
            {
                // Deletes executable report with provided uuid
                HvlResponseVoid result = apiInstance.deleteByUuid2(uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExecutableReportAPIApi.deleteByUuid2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiExecutableReportAPIApi();
$uuid = uuid_example; // String | 

try {
    $result = $api_instance->deleteByUuid2($uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExecutableReportAPIApi->deleteByUuid2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExecutableReportAPIApi;

my $api_instance = WWW::SwaggerClient::ExecutableReportAPIApi->new();
my $uuid = uuid_example; # String | 

eval { 
    my $result = $api_instance->deleteByUuid2(uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExecutableReportAPIApi->deleteByUuid2: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ExecutableReportAPIApi()
uuid = uuid_example # String | 

try: 
    # Deletes executable report with provided uuid
    api_response = api_instance.delete_by_uuid2(uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExecutableReportAPIApi->deleteByUuid2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExecutableReportAPIApi;

import java.io.File;
import java.util.*;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        String reportDataSourceType = reportDataSourceType_example; // String | 
        try {
            HvlResponseSetHvlRToolReportDataAdapterModel result = apiInstance.discoverReportDataAdapters(reportDataSourceType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#discoverReportDataAdapters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ExecutableReportAPIApi;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        String reportDataSourceType = reportDataSourceType_example; // String | 
        try {
            HvlResponseSetHvlRToolReportDataAdapterModel result = apiInstance.discoverReportDataAdapters(reportDataSourceType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#discoverReportDataAdapters");
            e.printStackTrace();
        }
    }
}

String *reportDataSourceType = reportDataSourceType_example; //  (optional)

ExecutableReportAPIApi *apiInstance = [[ExecutableReportAPIApi alloc] init];

// Discovers the report data adapters.
[apiInstance discoverReportDataAdaptersWith:reportDataSourceType
              completionHandler: ^(HvlResponseSetHvlRToolReportDataAdapterModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ExecutableReportAPIApi()
var opts = { 
  'reportDataSourceType': reportDataSourceType_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.discoverReportDataAdapters(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class discoverReportDataAdaptersExample
    {
        public void main()
        {

            var apiInstance = new ExecutableReportAPIApi();
            var reportDataSourceType = reportDataSourceType_example;  // String |  (optional) 

            try
            {
                // Discovers the report data adapters.
                HvlResponseSetHvlRToolReportDataAdapterModel result = apiInstance.discoverReportDataAdapters(reportDataSourceType);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExecutableReportAPIApi.discoverReportDataAdapters: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiExecutableReportAPIApi();
$reportDataSourceType = reportDataSourceType_example; // String | 

try {
    $result = $api_instance->discoverReportDataAdapters($reportDataSourceType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExecutableReportAPIApi->discoverReportDataAdapters: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExecutableReportAPIApi;

my $api_instance = WWW::SwaggerClient::ExecutableReportAPIApi->new();
my $reportDataSourceType = reportDataSourceType_example; # String | 

eval { 
    my $result = $api_instance->discoverReportDataAdapters(reportDataSourceType => $reportDataSourceType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExecutableReportAPIApi->discoverReportDataAdapters: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ExecutableReportAPIApi()
reportDataSourceType = reportDataSourceType_example # String |  (optional)

try: 
    # Discovers the report data adapters.
    api_response = api_instance.discover_report_data_adapters(reportDataSourceType=reportDataSourceType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExecutableReportAPIApi->discoverReportDataAdapters: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExecutableReportAPIApi;

import java.io.File;
import java.util.*;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseHvlRToolExecutableReportModel result = apiInstance.getByUuid2(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#getByUuid2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ExecutableReportAPIApi;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseHvlRToolExecutableReportModel result = apiInstance.getByUuid2(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#getByUuid2");
            e.printStackTrace();
        }
    }
}

String *uuid = uuid_example; // 

ExecutableReportAPIApi *apiInstance = [[ExecutableReportAPIApi alloc] init];

// Gets the executable report with provided uuid
[apiInstance getByUuid2With:uuid
              completionHandler: ^(HvlResponseHvlRToolExecutableReportModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ExecutableReportAPIApi()
var uuid = uuid_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getByUuid2(uuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getByUuid2Example
    {
        public void main()
        {

            var apiInstance = new ExecutableReportAPIApi();
            var uuid = uuid_example;  // String | 

            try
            {
                // Gets the executable report with provided uuid
                HvlResponseHvlRToolExecutableReportModel result = apiInstance.getByUuid2(uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExecutableReportAPIApi.getByUuid2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiExecutableReportAPIApi();
$uuid = uuid_example; // String | 

try {
    $result = $api_instance->getByUuid2($uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExecutableReportAPIApi->getByUuid2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExecutableReportAPIApi;

my $api_instance = WWW::SwaggerClient::ExecutableReportAPIApi->new();
my $uuid = uuid_example; # String | 

eval { 
    my $result = $api_instance->getByUuid2(uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExecutableReportAPIApi->getByUuid2: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ExecutableReportAPIApi()
uuid = uuid_example # String | 

try: 
    # Gets the executable report with provided uuid
    api_response = api_instance.get_by_uuid2(uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExecutableReportAPIApi->getByUuid2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExecutableReportAPIApi;

import java.io.File;
import java.util.*;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseSetHvlRToolReportExecutingParamModel result = apiInstance.getExecutingParamSetByUuid(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#getExecutingParamSetByUuid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ExecutableReportAPIApi;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseSetHvlRToolReportExecutingParamModel result = apiInstance.getExecutingParamSetByUuid(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#getExecutingParamSetByUuid");
            e.printStackTrace();
        }
    }
}

String *uuid = uuid_example; // 

ExecutableReportAPIApi *apiInstance = [[ExecutableReportAPIApi alloc] init];

// Gets the report executing params with provided uuid.
[apiInstance getExecutingParamSetByUuidWith:uuid
              completionHandler: ^(HvlResponseSetHvlRToolReportExecutingParamModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ExecutableReportAPIApi()
var uuid = uuid_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getExecutingParamSetByUuid(uuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getExecutingParamSetByUuidExample
    {
        public void main()
        {

            var apiInstance = new ExecutableReportAPIApi();
            var uuid = uuid_example;  // String | 

            try
            {
                // Gets the report executing params with provided uuid.
                HvlResponseSetHvlRToolReportExecutingParamModel result = apiInstance.getExecutingParamSetByUuid(uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExecutableReportAPIApi.getExecutingParamSetByUuid: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiExecutableReportAPIApi();
$uuid = uuid_example; // String | 

try {
    $result = $api_instance->getExecutingParamSetByUuid($uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExecutableReportAPIApi->getExecutingParamSetByUuid: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExecutableReportAPIApi;

my $api_instance = WWW::SwaggerClient::ExecutableReportAPIApi->new();
my $uuid = uuid_example; # String | 

eval { 
    my $result = $api_instance->getExecutingParamSetByUuid(uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExecutableReportAPIApi->getExecutingParamSetByUuid: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ExecutableReportAPIApi()
uuid = uuid_example # String | 

try: 
    # Gets the report executing params with provided uuid.
    api_response = api_instance.get_executing_param_set_by_uuid(uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExecutableReportAPIApi->getExecutingParamSetByUuid: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExecutableReportAPIApi;

import java.io.File;
import java.util.*;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        HvlRToolExecutableReportQueryModel body = ; // HvlRToolExecutableReportQueryModel | 
        try {
            HvlResponseListHvlRToolExecutableReportDataModel result = apiInstance.queryDataList2(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#queryDataList2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ExecutableReportAPIApi;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        HvlRToolExecutableReportQueryModel body = ; // HvlRToolExecutableReportQueryModel | 
        try {
            HvlResponseListHvlRToolExecutableReportDataModel result = apiInstance.queryDataList2(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#queryDataList2");
            e.printStackTrace();
        }
    }
}

HvlRToolExecutableReportQueryModel *body = ; // 

ExecutableReportAPIApi *apiInstance = [[ExecutableReportAPIApi alloc] init];

// Queries executable reports according to criteria in query model
[apiInstance queryDataList2With:body
              completionHandler: ^(HvlResponseListHvlRToolExecutableReportDataModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ExecutableReportAPIApi()
var body = ; // {{HvlRToolExecutableReportQueryModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.queryDataList2(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class queryDataList2Example
    {
        public void main()
        {

            var apiInstance = new ExecutableReportAPIApi();
            var body = new HvlRToolExecutableReportQueryModel(); // HvlRToolExecutableReportQueryModel | 

            try
            {
                // Queries executable reports according to criteria in query model
                HvlResponseListHvlRToolExecutableReportDataModel result = apiInstance.queryDataList2(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExecutableReportAPIApi.queryDataList2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiExecutableReportAPIApi();
$body = ; // HvlRToolExecutableReportQueryModel | 

try {
    $result = $api_instance->queryDataList2($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExecutableReportAPIApi->queryDataList2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExecutableReportAPIApi;

my $api_instance = WWW::SwaggerClient::ExecutableReportAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolExecutableReportQueryModel->new(); # HvlRToolExecutableReportQueryModel | 

eval { 
    my $result = $api_instance->queryDataList2(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExecutableReportAPIApi->queryDataList2: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ExecutableReportAPIApi()
body =  # HvlRToolExecutableReportQueryModel | 

try: 
    # Queries executable reports according to criteria in query model
    api_response = api_instance.query_data_list2(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExecutableReportAPIApi->queryDataList2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExecutableReportAPIApi;

import java.io.File;
import java.util.*;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        HvlRToolExecutableReportQueryModel body = ; // HvlRToolExecutableReportQueryModel | 
        try {
            HvlResponseHvlPageHvlRToolExecutableReportDataModel result = apiInstance.queryDataPage2(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#queryDataPage2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ExecutableReportAPIApi;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        HvlRToolExecutableReportQueryModel body = ; // HvlRToolExecutableReportQueryModel | 
        try {
            HvlResponseHvlPageHvlRToolExecutableReportDataModel result = apiInstance.queryDataPage2(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#queryDataPage2");
            e.printStackTrace();
        }
    }
}

HvlRToolExecutableReportQueryModel *body = ; // 

ExecutableReportAPIApi *apiInstance = [[ExecutableReportAPIApi alloc] init];

// Queries executable reports as paginated according to criteria in query model
[apiInstance queryDataPage2With:body
              completionHandler: ^(HvlResponseHvlPageHvlRToolExecutableReportDataModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ExecutableReportAPIApi()
var body = ; // {{HvlRToolExecutableReportQueryModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.queryDataPage2(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class queryDataPage2Example
    {
        public void main()
        {

            var apiInstance = new ExecutableReportAPIApi();
            var body = new HvlRToolExecutableReportQueryModel(); // HvlRToolExecutableReportQueryModel | 

            try
            {
                // Queries executable reports as paginated according to criteria in query model
                HvlResponseHvlPageHvlRToolExecutableReportDataModel result = apiInstance.queryDataPage2(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExecutableReportAPIApi.queryDataPage2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiExecutableReportAPIApi();
$body = ; // HvlRToolExecutableReportQueryModel | 

try {
    $result = $api_instance->queryDataPage2($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExecutableReportAPIApi->queryDataPage2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExecutableReportAPIApi;

my $api_instance = WWW::SwaggerClient::ExecutableReportAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolExecutableReportQueryModel->new(); # HvlRToolExecutableReportQueryModel | 

eval { 
    my $result = $api_instance->queryDataPage2(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExecutableReportAPIApi->queryDataPage2: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ExecutableReportAPIApi()
body =  # HvlRToolExecutableReportQueryModel | 

try: 
    # Queries executable reports as paginated according to criteria in query model
    api_response = api_instance.query_data_page2(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExecutableReportAPIApi->queryDataPage2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExecutableReportAPIApi;

import java.io.File;
import java.util.*;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        array[byte[]] reportTemplateAttrSources = ; // array[byte[]] | 
        try {
            HvlResponseHvlRToolResolvedReportTemplateModel result = apiInstance.resolveReportTemplate(reportTemplateAttrSources);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#resolveReportTemplate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ExecutableReportAPIApi;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        array[byte[]] reportTemplateAttrSources = ; // array[byte[]] | 
        try {
            HvlResponseHvlRToolResolvedReportTemplateModel result = apiInstance.resolveReportTemplate(reportTemplateAttrSources);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#resolveReportTemplate");
            e.printStackTrace();
        }
    }
}

array[byte[]] *reportTemplateAttrSources = ; // 

ExecutableReportAPIApi *apiInstance = [[ExecutableReportAPIApi alloc] init];

// Resolves the executable report template content.
[apiInstance resolveReportTemplateWith:reportTemplateAttrSources
              completionHandler: ^(HvlResponseHvlRToolResolvedReportTemplateModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ExecutableReportAPIApi()
var reportTemplateAttrSources = ; // {{array[byte[]]}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.resolveReportTemplate(reportTemplateAttrSources, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class resolveReportTemplateExample
    {
        public void main()
        {

            var apiInstance = new ExecutableReportAPIApi();
            var reportTemplateAttrSources = new array[byte[]](); // array[byte[]] | 

            try
            {
                // Resolves the executable report template content.
                HvlResponseHvlRToolResolvedReportTemplateModel result = apiInstance.resolveReportTemplate(reportTemplateAttrSources);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExecutableReportAPIApi.resolveReportTemplate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiExecutableReportAPIApi();
$reportTemplateAttrSources = ; // array[byte[]] | 

try {
    $result = $api_instance->resolveReportTemplate($reportTemplateAttrSources);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExecutableReportAPIApi->resolveReportTemplate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExecutableReportAPIApi;

my $api_instance = WWW::SwaggerClient::ExecutableReportAPIApi->new();
my $reportTemplateAttrSources = []; # array[byte[]] | 

eval { 
    my $result = $api_instance->resolveReportTemplate(reportTemplateAttrSources => $reportTemplateAttrSources);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExecutableReportAPIApi->resolveReportTemplate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ExecutableReportAPIApi()
reportTemplateAttrSources =  # array[byte[]] | 

try: 
    # Resolves the executable report template content.
    api_response = api_instance.resolve_report_template(reportTemplateAttrSources)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExecutableReportAPIApi->resolveReportTemplate: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExecutableReportAPIApi;

import java.io.File;
import java.util.*;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        HvlRToolExecutableReportModel body = ; // HvlRToolExecutableReportModel | 
        try {
            HvlResponseVoid result = apiInstance.save2(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#save2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ExecutableReportAPIApi;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        HvlRToolExecutableReportModel body = ; // HvlRToolExecutableReportModel | 
        try {
            HvlResponseVoid result = apiInstance.save2(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#save2");
            e.printStackTrace();
        }
    }
}

HvlRToolExecutableReportModel *body = ; // 

ExecutableReportAPIApi *apiInstance = [[ExecutableReportAPIApi alloc] init];

// Saves executable report
[apiInstance save2With:body
              completionHandler: ^(HvlResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ExecutableReportAPIApi()
var body = ; // {{HvlRToolExecutableReportModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.save2(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class save2Example
    {
        public void main()
        {

            var apiInstance = new ExecutableReportAPIApi();
            var body = new HvlRToolExecutableReportModel(); // HvlRToolExecutableReportModel | 

            try
            {
                // Saves executable report
                HvlResponseVoid result = apiInstance.save2(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExecutableReportAPIApi.save2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiExecutableReportAPIApi();
$body = ; // HvlRToolExecutableReportModel | 

try {
    $result = $api_instance->save2($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExecutableReportAPIApi->save2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExecutableReportAPIApi;

my $api_instance = WWW::SwaggerClient::ExecutableReportAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolExecutableReportModel->new(); # HvlRToolExecutableReportModel | 

eval { 
    my $result = $api_instance->save2(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExecutableReportAPIApi->save2: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ExecutableReportAPIApi()
body =  # HvlRToolExecutableReportModel | 

try: 
    # Saves executable report
    api_response = api_instance.save2(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExecutableReportAPIApi->save2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExecutableReportAPIApi;

import java.io.File;
import java.util.*;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        HvlRToolExecutableReportModel body = ; // HvlRToolExecutableReportModel | 
        try {
            HvlResponseVoid result = apiInstance.update2(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#update2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ExecutableReportAPIApi;

public class ExecutableReportAPIApiExample {

    public static void main(String[] args) {
        ExecutableReportAPIApi apiInstance = new ExecutableReportAPIApi();
        HvlRToolExecutableReportModel body = ; // HvlRToolExecutableReportModel | 
        try {
            HvlResponseVoid result = apiInstance.update2(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExecutableReportAPIApi#update2");
            e.printStackTrace();
        }
    }
}

HvlRToolExecutableReportModel *body = ; // 

ExecutableReportAPIApi *apiInstance = [[ExecutableReportAPIApi alloc] init];

// Updates executable report
[apiInstance update2With:body
              completionHandler: ^(HvlResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ExecutableReportAPIApi()
var body = ; // {{HvlRToolExecutableReportModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.update2(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class update2Example
    {
        public void main()
        {

            var apiInstance = new ExecutableReportAPIApi();
            var body = new HvlRToolExecutableReportModel(); // HvlRToolExecutableReportModel | 

            try
            {
                // Updates executable report
                HvlResponseVoid result = apiInstance.update2(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExecutableReportAPIApi.update2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiExecutableReportAPIApi();
$body = ; // HvlRToolExecutableReportModel | 

try {
    $result = $api_instance->update2($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExecutableReportAPIApi->update2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExecutableReportAPIApi;

my $api_instance = WWW::SwaggerClient::ExecutableReportAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolExecutableReportModel->new(); # HvlRToolExecutableReportModel | 

eval { 
    my $result = $api_instance->update2(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExecutableReportAPIApi->update2: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ExecutableReportAPIApi()
body =  # HvlRToolExecutableReportModel | 

try: 
    # Updates executable report
    api_response = api_instance.update2(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExecutableReportAPIApi->update2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportGroupAPIApi;

import java.io.File;
import java.util.*;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseVoid result = apiInstance.deleteByUuid1(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#deleteByUuid1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportGroupAPIApi;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseVoid result = apiInstance.deleteByUuid1(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#deleteByUuid1");
            e.printStackTrace();
        }
    }
}

String *uuid = uuid_example; // 

ReportGroupAPIApi *apiInstance = [[ReportGroupAPIApi alloc] init];

// Deletes report group with provided uuid
[apiInstance deleteByUuid1With:uuid
              completionHandler: ^(HvlResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportGroupAPIApi()
var uuid = uuid_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteByUuid1(uuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteByUuid1Example
    {
        public void main()
        {

            var apiInstance = new ReportGroupAPIApi();
            var uuid = uuid_example;  // String | 

            try
            {
                // Deletes report group with provided uuid
                HvlResponseVoid result = apiInstance.deleteByUuid1(uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportGroupAPIApi.deleteByUuid1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportGroupAPIApi();
$uuid = uuid_example; // String | 

try {
    $result = $api_instance->deleteByUuid1($uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportGroupAPIApi->deleteByUuid1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportGroupAPIApi;

my $api_instance = WWW::SwaggerClient::ReportGroupAPIApi->new();
my $uuid = uuid_example; # String | 

eval { 
    my $result = $api_instance->deleteByUuid1(uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportGroupAPIApi->deleteByUuid1: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportGroupAPIApi()
uuid = uuid_example # String | 

try: 
    # Deletes report group with provided uuid
    api_response = api_instance.delete_by_uuid1(uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportGroupAPIApi->deleteByUuid1: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportGroupAPIApi;

import java.io.File;
import java.util.*;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseHvlRToolReportGroupModel result = apiInstance.getByUuid1(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#getByUuid1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportGroupAPIApi;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseHvlRToolReportGroupModel result = apiInstance.getByUuid1(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#getByUuid1");
            e.printStackTrace();
        }
    }
}

String *uuid = uuid_example; // 

ReportGroupAPIApi *apiInstance = [[ReportGroupAPIApi alloc] init];

// Gets the report group with provided uuid
[apiInstance getByUuid1With:uuid
              completionHandler: ^(HvlResponseHvlRToolReportGroupModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportGroupAPIApi()
var uuid = uuid_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getByUuid1(uuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getByUuid1Example
    {
        public void main()
        {

            var apiInstance = new ReportGroupAPIApi();
            var uuid = uuid_example;  // String | 

            try
            {
                // Gets the report group with provided uuid
                HvlResponseHvlRToolReportGroupModel result = apiInstance.getByUuid1(uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportGroupAPIApi.getByUuid1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportGroupAPIApi();
$uuid = uuid_example; // String | 

try {
    $result = $api_instance->getByUuid1($uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportGroupAPIApi->getByUuid1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportGroupAPIApi;

my $api_instance = WWW::SwaggerClient::ReportGroupAPIApi->new();
my $uuid = uuid_example; # String | 

eval { 
    my $result = $api_instance->getByUuid1(uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportGroupAPIApi->getByUuid1: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportGroupAPIApi()
uuid = uuid_example # String | 

try: 
    # Gets the report group with provided uuid
    api_response = api_instance.get_by_uuid1(uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportGroupAPIApi->getByUuid1: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportGroupAPIApi;

import java.io.File;
import java.util.*;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        HvlRToolReportGroupQueryModel body = ; // HvlRToolReportGroupQueryModel | 
        try {
            HvlResponseListHvlRToolReportGroupDataModel result = apiInstance.queryDataList1(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#queryDataList1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportGroupAPIApi;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        HvlRToolReportGroupQueryModel body = ; // HvlRToolReportGroupQueryModel | 
        try {
            HvlResponseListHvlRToolReportGroupDataModel result = apiInstance.queryDataList1(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#queryDataList1");
            e.printStackTrace();
        }
    }
}

HvlRToolReportGroupQueryModel *body = ; // 

ReportGroupAPIApi *apiInstance = [[ReportGroupAPIApi alloc] init];

// Queries report groups according to criteria in query model
[apiInstance queryDataList1With:body
              completionHandler: ^(HvlResponseListHvlRToolReportGroupDataModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportGroupAPIApi()
var body = ; // {{HvlRToolReportGroupQueryModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.queryDataList1(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class queryDataList1Example
    {
        public void main()
        {

            var apiInstance = new ReportGroupAPIApi();
            var body = new HvlRToolReportGroupQueryModel(); // HvlRToolReportGroupQueryModel | 

            try
            {
                // Queries report groups according to criteria in query model
                HvlResponseListHvlRToolReportGroupDataModel result = apiInstance.queryDataList1(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportGroupAPIApi.queryDataList1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportGroupAPIApi();
$body = ; // HvlRToolReportGroupQueryModel | 

try {
    $result = $api_instance->queryDataList1($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportGroupAPIApi->queryDataList1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportGroupAPIApi;

my $api_instance = WWW::SwaggerClient::ReportGroupAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolReportGroupQueryModel->new(); # HvlRToolReportGroupQueryModel | 

eval { 
    my $result = $api_instance->queryDataList1(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportGroupAPIApi->queryDataList1: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportGroupAPIApi()
body =  # HvlRToolReportGroupQueryModel | 

try: 
    # Queries report groups according to criteria in query model
    api_response = api_instance.query_data_list1(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportGroupAPIApi->queryDataList1: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportGroupAPIApi;

import java.io.File;
import java.util.*;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        HvlRToolReportGroupQueryModel body = ; // HvlRToolReportGroupQueryModel | 
        try {
            HvlResponseHvlPageHvlRToolReportGroupDataModel result = apiInstance.queryDataPage1(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#queryDataPage1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportGroupAPIApi;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        HvlRToolReportGroupQueryModel body = ; // HvlRToolReportGroupQueryModel | 
        try {
            HvlResponseHvlPageHvlRToolReportGroupDataModel result = apiInstance.queryDataPage1(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#queryDataPage1");
            e.printStackTrace();
        }
    }
}

HvlRToolReportGroupQueryModel *body = ; // 

ReportGroupAPIApi *apiInstance = [[ReportGroupAPIApi alloc] init];

// Queries report groups as paginated according to criteria in query model
[apiInstance queryDataPage1With:body
              completionHandler: ^(HvlResponseHvlPageHvlRToolReportGroupDataModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportGroupAPIApi()
var body = ; // {{HvlRToolReportGroupQueryModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.queryDataPage1(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class queryDataPage1Example
    {
        public void main()
        {

            var apiInstance = new ReportGroupAPIApi();
            var body = new HvlRToolReportGroupQueryModel(); // HvlRToolReportGroupQueryModel | 

            try
            {
                // Queries report groups as paginated according to criteria in query model
                HvlResponseHvlPageHvlRToolReportGroupDataModel result = apiInstance.queryDataPage1(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportGroupAPIApi.queryDataPage1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportGroupAPIApi();
$body = ; // HvlRToolReportGroupQueryModel | 

try {
    $result = $api_instance->queryDataPage1($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportGroupAPIApi->queryDataPage1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportGroupAPIApi;

my $api_instance = WWW::SwaggerClient::ReportGroupAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolReportGroupQueryModel->new(); # HvlRToolReportGroupQueryModel | 

eval { 
    my $result = $api_instance->queryDataPage1(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportGroupAPIApi->queryDataPage1: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportGroupAPIApi()
body =  # HvlRToolReportGroupQueryModel | 

try: 
    # Queries report groups as paginated according to criteria in query model
    api_response = api_instance.query_data_page1(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportGroupAPIApi->queryDataPage1: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportGroupAPIApi;

import java.io.File;
import java.util.*;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        HvlRToolReportGroupQueryModel body = ; // HvlRToolReportGroupQueryModel | 
        try {
            HvlResponseListHvlRToolReportGroupLookupDataModel result = apiInstance.queryLookupDataList(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#queryLookupDataList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportGroupAPIApi;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        HvlRToolReportGroupQueryModel body = ; // HvlRToolReportGroupQueryModel | 
        try {
            HvlResponseListHvlRToolReportGroupLookupDataModel result = apiInstance.queryLookupDataList(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#queryLookupDataList");
            e.printStackTrace();
        }
    }
}

HvlRToolReportGroupQueryModel *body = ; // 

ReportGroupAPIApi *apiInstance = [[ReportGroupAPIApi alloc] init];

// Queries lookup data of report groups according to criteria in query model
[apiInstance queryLookupDataListWith:body
              completionHandler: ^(HvlResponseListHvlRToolReportGroupLookupDataModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportGroupAPIApi()
var body = ; // {{HvlRToolReportGroupQueryModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.queryLookupDataList(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class queryLookupDataListExample
    {
        public void main()
        {

            var apiInstance = new ReportGroupAPIApi();
            var body = new HvlRToolReportGroupQueryModel(); // HvlRToolReportGroupQueryModel | 

            try
            {
                // Queries lookup data of report groups according to criteria in query model
                HvlResponseListHvlRToolReportGroupLookupDataModel result = apiInstance.queryLookupDataList(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportGroupAPIApi.queryLookupDataList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportGroupAPIApi();
$body = ; // HvlRToolReportGroupQueryModel | 

try {
    $result = $api_instance->queryLookupDataList($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportGroupAPIApi->queryLookupDataList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportGroupAPIApi;

my $api_instance = WWW::SwaggerClient::ReportGroupAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolReportGroupQueryModel->new(); # HvlRToolReportGroupQueryModel | 

eval { 
    my $result = $api_instance->queryLookupDataList(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportGroupAPIApi->queryLookupDataList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportGroupAPIApi()
body =  # HvlRToolReportGroupQueryModel | 

try: 
    # Queries lookup data of report groups according to criteria in query model
    api_response = api_instance.query_lookup_data_list(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportGroupAPIApi->queryLookupDataList: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportGroupAPIApi;

import java.io.File;
import java.util.*;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        HvlRToolReportGroupModel body = ; // HvlRToolReportGroupModel | 
        try {
            HvlResponseVoid result = apiInstance.save1(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#save1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportGroupAPIApi;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        HvlRToolReportGroupModel body = ; // HvlRToolReportGroupModel | 
        try {
            HvlResponseVoid result = apiInstance.save1(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#save1");
            e.printStackTrace();
        }
    }
}

HvlRToolReportGroupModel *body = ; // 

ReportGroupAPIApi *apiInstance = [[ReportGroupAPIApi alloc] init];

// Saves report group
[apiInstance save1With:body
              completionHandler: ^(HvlResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportGroupAPIApi()
var body = ; // {{HvlRToolReportGroupModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.save1(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class save1Example
    {
        public void main()
        {

            var apiInstance = new ReportGroupAPIApi();
            var body = new HvlRToolReportGroupModel(); // HvlRToolReportGroupModel | 

            try
            {
                // Saves report group
                HvlResponseVoid result = apiInstance.save1(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportGroupAPIApi.save1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportGroupAPIApi();
$body = ; // HvlRToolReportGroupModel | 

try {
    $result = $api_instance->save1($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportGroupAPIApi->save1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportGroupAPIApi;

my $api_instance = WWW::SwaggerClient::ReportGroupAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolReportGroupModel->new(); # HvlRToolReportGroupModel | 

eval { 
    my $result = $api_instance->save1(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportGroupAPIApi->save1: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportGroupAPIApi()
body =  # HvlRToolReportGroupModel | 

try: 
    # Saves report group
    api_response = api_instance.save1(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportGroupAPIApi->save1: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportGroupAPIApi;

import java.io.File;
import java.util.*;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        HvlRToolReportGroupModel body = ; // HvlRToolReportGroupModel | 
        try {
            HvlResponseVoid result = apiInstance.update1(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#update1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportGroupAPIApi;

public class ReportGroupAPIApiExample {

    public static void main(String[] args) {
        ReportGroupAPIApi apiInstance = new ReportGroupAPIApi();
        HvlRToolReportGroupModel body = ; // HvlRToolReportGroupModel | 
        try {
            HvlResponseVoid result = apiInstance.update1(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportGroupAPIApi#update1");
            e.printStackTrace();
        }
    }
}

HvlRToolReportGroupModel *body = ; // 

ReportGroupAPIApi *apiInstance = [[ReportGroupAPIApi alloc] init];

// Updates report group
[apiInstance update1With:body
              completionHandler: ^(HvlResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportGroupAPIApi()
var body = ; // {{HvlRToolReportGroupModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.update1(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class update1Example
    {
        public void main()
        {

            var apiInstance = new ReportGroupAPIApi();
            var body = new HvlRToolReportGroupModel(); // HvlRToolReportGroupModel | 

            try
            {
                // Updates report group
                HvlResponseVoid result = apiInstance.update1(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportGroupAPIApi.update1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportGroupAPIApi();
$body = ; // HvlRToolReportGroupModel | 

try {
    $result = $api_instance->update1($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportGroupAPIApi->update1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportGroupAPIApi;

my $api_instance = WWW::SwaggerClient::ReportGroupAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolReportGroupModel->new(); # HvlRToolReportGroupModel | 

eval { 
    my $result = $api_instance->update1(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportGroupAPIApi->update1: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportGroupAPIApi()
body =  # HvlRToolReportGroupModel | 

try: 
    # Updates report group
    api_response = api_instance.update1(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportGroupAPIApi->update1: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperAPIApi apiInstance = new ReportJasperAPIApi();
        try {
            HvlResponseListHvlJasperReportModel result = apiInstance.getAllReportList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperAPIApi#getAllReportList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperAPIApi;

public class ReportJasperAPIApiExample {

    public static void main(String[] args) {
        ReportJasperAPIApi apiInstance = new ReportJasperAPIApi();
        try {
            HvlResponseListHvlJasperReportModel result = apiInstance.getAllReportList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperAPIApi#getAllReportList");
            e.printStackTrace();
        }
    }
}

ReportJasperAPIApi *apiInstance = [[ReportJasperAPIApi alloc] init];

// Gets all reports list on TIBCO Jasper Server
[apiInstance getAllReportListWithCompletionHandler: 
              ^(HvlResponseListHvlJasperReportModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperAPIApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllReportList(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAllReportListExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperAPIApi();

            try
            {
                // Gets all reports list on TIBCO Jasper Server
                HvlResponseListHvlJasperReportModel result = apiInstance.getAllReportList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperAPIApi.getAllReportList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperAPIApi();

try {
    $result = $api_instance->getAllReportList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperAPIApi->getAllReportList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperAPIApi->new();

eval { 
    my $result = $api_instance->getAllReportList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperAPIApi->getAllReportList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperAPIApi()

try: 
    # Gets all reports list on TIBCO Jasper Server
    api_response = api_instance.get_all_report_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperAPIApi->getAllReportList: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperAPIApi apiInstance = new ReportJasperAPIApi();
        String reportUri = reportUri_example; // String | 
        try {
            HvlResponseListReportInputControl result = apiInstance.getReportInputControlList(reportUri);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperAPIApi#getReportInputControlList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperAPIApi;

public class ReportJasperAPIApiExample {

    public static void main(String[] args) {
        ReportJasperAPIApi apiInstance = new ReportJasperAPIApi();
        String reportUri = reportUri_example; // String | 
        try {
            HvlResponseListReportInputControl result = apiInstance.getReportInputControlList(reportUri);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperAPIApi#getReportInputControlList");
            e.printStackTrace();
        }
    }
}

String *reportUri = reportUri_example; // 

ReportJasperAPIApi *apiInstance = [[ReportJasperAPIApi alloc] init];

// Gets input control list of a specific report
[apiInstance getReportInputControlListWith:reportUri
              completionHandler: ^(HvlResponseListReportInputControl output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperAPIApi()
var reportUri = reportUri_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getReportInputControlList(reportUri, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getReportInputControlListExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperAPIApi();
            var reportUri = reportUri_example;  // String | 

            try
            {
                // Gets input control list of a specific report
                HvlResponseListReportInputControl result = apiInstance.getReportInputControlList(reportUri);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperAPIApi.getReportInputControlList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperAPIApi();
$reportUri = reportUri_example; // String | 

try {
    $result = $api_instance->getReportInputControlList($reportUri);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperAPIApi->getReportInputControlList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperAPIApi->new();
my $reportUri = reportUri_example; # String | 

eval { 
    my $result = $api_instance->getReportInputControlList(reportUri => $reportUri);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperAPIApi->getReportInputControlList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperAPIApi()
reportUri = reportUri_example # String | 

try: 
    # Gets input control list of a specific report
    api_response = api_instance.get_report_input_control_list(reportUri)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperAPIApi->getReportInputControlList: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperAPIApi apiInstance = new ReportJasperAPIApi();
        HvlJasperReportLogQueryModel body = ; // HvlJasperReportLogQueryModel | 
        try {
            HvlResponseHvlPageHvlEventLogModel result = apiInstance.queryReportLog(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperAPIApi#queryReportLog");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperAPIApi;

public class ReportJasperAPIApiExample {

    public static void main(String[] args) {
        ReportJasperAPIApi apiInstance = new ReportJasperAPIApi();
        HvlJasperReportLogQueryModel body = ; // HvlJasperReportLogQueryModel | 
        try {
            HvlResponseHvlPageHvlEventLogModel result = apiInstance.queryReportLog(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperAPIApi#queryReportLog");
            e.printStackTrace();
        }
    }
}

HvlJasperReportLogQueryModel *body = ; // 

ReportJasperAPIApi *apiInstance = [[ReportJasperAPIApi alloc] init];

// Query method for report event logs
[apiInstance queryReportLogWith:body
              completionHandler: ^(HvlResponseHvlPageHvlEventLogModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperAPIApi()
var body = ; // {{HvlJasperReportLogQueryModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.queryReportLog(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class queryReportLogExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperAPIApi();
            var body = new HvlJasperReportLogQueryModel(); // HvlJasperReportLogQueryModel | 

            try
            {
                // Query method for report event logs
                HvlResponseHvlPageHvlEventLogModel result = apiInstance.queryReportLog(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperAPIApi.queryReportLog: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperAPIApi();
$body = ; // HvlJasperReportLogQueryModel | 

try {
    $result = $api_instance->queryReportLog($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperAPIApi->queryReportLog: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlJasperReportLogQueryModel->new(); # HvlJasperReportLogQueryModel | 

eval { 
    my $result = $api_instance->queryReportLog(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperAPIApi->queryReportLog: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperAPIApi()
body =  # HvlJasperReportLogQueryModel | 

try: 
    # Query method for report event logs
    api_response = api_instance.query_report_log(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperAPIApi->queryReportLog: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        String executionId = executionId_example; // String | 
        try {
            HvlResponseVoid result = apiInstance.cancel(executionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#cancel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionAPIApi;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        String executionId = executionId_example; // String | 
        try {
            HvlResponseVoid result = apiInstance.cancel(executionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#cancel");
            e.printStackTrace();
        }
    }
}

String *executionId = executionId_example; // 

ReportJasperExecutionAPIApi *apiInstance = [[ReportJasperExecutionAPIApi alloc] init];

// Cancels a report which is executing
[apiInstance cancelWith:executionId
              completionHandler: ^(HvlResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionAPIApi()
var executionId = executionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.cancel(executionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class cancelExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionAPIApi();
            var executionId = executionId_example;  // String | 

            try
            {
                // Cancels a report which is executing
                HvlResponseVoid result = apiInstance.cancel(executionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionAPIApi.cancel: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionAPIApi();
$executionId = executionId_example; // String | 

try {
    $result = $api_instance->cancel($executionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionAPIApi->cancel: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionAPIApi->new();
my $executionId = executionId_example; # String | 

eval { 
    my $result = $api_instance->cancel(executionId => $executionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionAPIApi->cancel: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionAPIApi()
executionId = executionId_example # String | 

try: 
    # Cancels a report which is executing
    api_response = api_instance.cancel(executionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionAPIApi->cancel: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        String executionId = executionId_example; // String | 
        try {
            HvlResponseVoid result = apiInstance.delete(executionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#delete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionAPIApi;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        String executionId = executionId_example; // String | 
        try {
            HvlResponseVoid result = apiInstance.delete(executionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#delete");
            e.printStackTrace();
        }
    }
}

String *executionId = executionId_example; // 

ReportJasperExecutionAPIApi *apiInstance = [[ReportJasperExecutionAPIApi alloc] init];

// Deletes a report which is executing
[apiInstance deleteWith:executionId
              completionHandler: ^(HvlResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionAPIApi()
var executionId = executionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.delete(executionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionAPIApi();
            var executionId = executionId_example;  // String | 

            try
            {
                // Deletes a report which is executing
                HvlResponseVoid result = apiInstance.delete(executionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionAPIApi.delete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionAPIApi();
$executionId = executionId_example; // String | 

try {
    $result = $api_instance->delete($executionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionAPIApi->delete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionAPIApi->new();
my $executionId = executionId_example; # String | 

eval { 
    my $result = $api_instance->delete(executionId => $executionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionAPIApi->delete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionAPIApi()
executionId = executionId_example # String | 

try: 
    # Deletes a report which is executing
    api_response = api_instance.delete(executionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionAPIApi->delete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        String executionId = executionId_example; // String | 
        try {
            HvlResponseHvlJasperReportExecutionModel result = apiInstance.getDetails(executionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#getDetails");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionAPIApi;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        String executionId = executionId_example; // String | 
        try {
            HvlResponseHvlJasperReportExecutionModel result = apiInstance.getDetails(executionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#getDetails");
            e.printStackTrace();
        }
    }
}

String *executionId = executionId_example; // 

ReportJasperExecutionAPIApi *apiInstance = [[ReportJasperExecutionAPIApi alloc] init];

// Gets report execution details
[apiInstance getDetailsWith:executionId
              completionHandler: ^(HvlResponseHvlJasperReportExecutionModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionAPIApi()
var executionId = executionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDetails(executionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getDetailsExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionAPIApi();
            var executionId = executionId_example;  // String | 

            try
            {
                // Gets report execution details
                HvlResponseHvlJasperReportExecutionModel result = apiInstance.getDetails(executionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionAPIApi.getDetails: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionAPIApi();
$executionId = executionId_example; // String | 

try {
    $result = $api_instance->getDetails($executionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionAPIApi->getDetails: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionAPIApi->new();
my $executionId = executionId_example; # String | 

eval { 
    my $result = $api_instance->getDetails(executionId => $executionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionAPIApi->getDetails: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionAPIApi()
executionId = executionId_example # String | 

try: 
    # Gets report execution details
    api_response = api_instance.get_details(executionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionAPIApi->getDetails: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        String executionId = executionId_example; // String | 
        try {
            HvlResponseExecutionStatus result = apiInstance.getExecutionStatus(executionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#getExecutionStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionAPIApi;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        String executionId = executionId_example; // String | 
        try {
            HvlResponseExecutionStatus result = apiInstance.getExecutionStatus(executionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#getExecutionStatus");
            e.printStackTrace();
        }
    }
}

String *executionId = executionId_example; // 

ReportJasperExecutionAPIApi *apiInstance = [[ReportJasperExecutionAPIApi alloc] init];

// Gets report execution status
[apiInstance getExecutionStatusWith:executionId
              completionHandler: ^(HvlResponseExecutionStatus output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionAPIApi()
var executionId = executionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getExecutionStatus(executionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getExecutionStatusExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionAPIApi();
            var executionId = executionId_example;  // String | 

            try
            {
                // Gets report execution status
                HvlResponseExecutionStatus result = apiInstance.getExecutionStatus(executionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionAPIApi.getExecutionStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionAPIApi();
$executionId = executionId_example; // String | 

try {
    $result = $api_instance->getExecutionStatus($executionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionAPIApi->getExecutionStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionAPIApi->new();
my $executionId = executionId_example; # String | 

eval { 
    my $result = $api_instance->getExecutionStatus(executionId => $executionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionAPIApi->getExecutionStatus: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionAPIApi()
executionId = executionId_example # String | 

try: 
    # Gets report execution status
    api_response = api_instance.get_execution_status(executionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionAPIApi->getExecutionStatus: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        String executionId = executionId_example; // String | 
        String exportId = exportId_example; // String | 
        try {
            HvlResponseHvlReportExecutionStatusEntityModel result = apiInstance.getExportExecutionStatus(executionId, exportId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#getExportExecutionStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionAPIApi;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        String executionId = executionId_example; // String | 
        String exportId = exportId_example; // String | 
        try {
            HvlResponseHvlReportExecutionStatusEntityModel result = apiInstance.getExportExecutionStatus(executionId, exportId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#getExportExecutionStatus");
            e.printStackTrace();
        }
    }
}

String *executionId = executionId_example; // 
String *exportId = exportId_example; // 

ReportJasperExecutionAPIApi *apiInstance = [[ReportJasperExecutionAPIApi alloc] init];

// Gets export execution status
[apiInstance getExportExecutionStatusWith:executionId
    exportId:exportId
              completionHandler: ^(HvlResponseHvlReportExecutionStatusEntityModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionAPIApi()
var executionId = executionId_example; // {{String}} 
var exportId = exportId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getExportExecutionStatus(executionId, exportId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getExportExecutionStatusExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionAPIApi();
            var executionId = executionId_example;  // String | 
            var exportId = exportId_example;  // String | 

            try
            {
                // Gets export execution status
                HvlResponseHvlReportExecutionStatusEntityModel result = apiInstance.getExportExecutionStatus(executionId, exportId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionAPIApi.getExportExecutionStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionAPIApi();
$executionId = executionId_example; // String | 
$exportId = exportId_example; // String | 

try {
    $result = $api_instance->getExportExecutionStatus($executionId, $exportId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionAPIApi->getExportExecutionStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionAPIApi->new();
my $executionId = executionId_example; # String | 
my $exportId = exportId_example; # String | 

eval { 
    my $result = $api_instance->getExportExecutionStatus(executionId => $executionId, exportId => $exportId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionAPIApi->getExportExecutionStatus: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionAPIApi()
executionId = executionId_example # String | 
exportId = exportId_example # String | 

try: 
    # Gets export execution status
    api_response = api_instance.get_export_execution_status(executionId, exportId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionAPIApi->getExportExecutionStatus: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        String executionId = executionId_example; // String | 
        String exportId = exportId_example; // String | 
        Boolean forDownload = true; // Boolean | 
        try {
            array[byte[]] result = apiInstance.getOutputResourceAttachment(executionId, exportId, forDownload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#getOutputResourceAttachment");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionAPIApi;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        String executionId = executionId_example; // String | 
        String exportId = exportId_example; // String | 
        Boolean forDownload = true; // Boolean | 
        try {
            array[byte[]] result = apiInstance.getOutputResourceAttachment(executionId, exportId, forDownload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#getOutputResourceAttachment");
            e.printStackTrace();
        }
    }
}

String *executionId = executionId_example; // 
String *exportId = exportId_example; // 
Boolean *forDownload = true; // 

ReportJasperExecutionAPIApi *apiInstance = [[ReportJasperExecutionAPIApi alloc] init];

// Gets output resource attachment
[apiInstance getOutputResourceAttachmentWith:executionId
    exportId:exportId
    forDownload:forDownload
              completionHandler: ^(array[byte[]] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionAPIApi()
var executionId = executionId_example; // {{String}} 
var exportId = exportId_example; // {{String}} 
var forDownload = true; // {{Boolean}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getOutputResourceAttachment(executionId, exportId, forDownload, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getOutputResourceAttachmentExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionAPIApi();
            var executionId = executionId_example;  // String | 
            var exportId = exportId_example;  // String | 
            var forDownload = true;  // Boolean | 

            try
            {
                // Gets output resource attachment
                array[byte[]] result = apiInstance.getOutputResourceAttachment(executionId, exportId, forDownload);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionAPIApi.getOutputResourceAttachment: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionAPIApi();
$executionId = executionId_example; // String | 
$exportId = exportId_example; // String | 
$forDownload = true; // Boolean | 

try {
    $result = $api_instance->getOutputResourceAttachment($executionId, $exportId, $forDownload);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionAPIApi->getOutputResourceAttachment: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionAPIApi->new();
my $executionId = executionId_example; # String | 
my $exportId = exportId_example; # String | 
my $forDownload = true; # Boolean | 

eval { 
    my $result = $api_instance->getOutputResourceAttachment(executionId => $executionId, exportId => $exportId, forDownload => $forDownload);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionAPIApi->getOutputResourceAttachment: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionAPIApi()
executionId = executionId_example # String | 
exportId = exportId_example # String | 
forDownload = true # Boolean | 

try: 
    # Gets output resource attachment
    api_response = api_instance.get_output_resource_attachment(executionId, exportId, forDownload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionAPIApi->getOutputResourceAttachment: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        ReportParameters body = ; // ReportParameters | 
        String executionId = executionId_example; // String | 
        try {
            HvlResponseVoid result = apiInstance.updateReportParameters(body, executionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#updateReportParameters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionAPIApi;

public class ReportJasperExecutionAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionAPIApi apiInstance = new ReportJasperExecutionAPIApi();
        ReportParameters body = ; // ReportParameters | 
        String executionId = executionId_example; // String | 
        try {
            HvlResponseVoid result = apiInstance.updateReportParameters(body, executionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAPIApi#updateReportParameters");
            e.printStackTrace();
        }
    }
}

ReportParameters *body = ; // 
String *executionId = executionId_example; // 

ReportJasperExecutionAPIApi *apiInstance = [[ReportJasperExecutionAPIApi alloc] init];

// Updates report parameters
[apiInstance updateReportParametersWith:body
    executionId:executionId
              completionHandler: ^(HvlResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionAPIApi()
var body = ; // {{ReportParameters}} 
var executionId = executionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateReportParameters(bodyexecutionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateReportParametersExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionAPIApi();
            var body = new ReportParameters(); // ReportParameters | 
            var executionId = executionId_example;  // String | 

            try
            {
                // Updates report parameters
                HvlResponseVoid result = apiInstance.updateReportParameters(body, executionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionAPIApi.updateReportParameters: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionAPIApi();
$body = ; // ReportParameters | 
$executionId = executionId_example; // String | 

try {
    $result = $api_instance->updateReportParameters($body, $executionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionAPIApi->updateReportParameters: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionAPIApi->new();
my $body = WWW::SwaggerClient::Object::ReportParameters->new(); # ReportParameters | 
my $executionId = executionId_example; # String | 

eval { 
    my $result = $api_instance->updateReportParameters(body => $body, executionId => $executionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionAPIApi->updateReportParameters: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionAPIApi()
body =  # ReportParameters | 
executionId = executionId_example # String | 

try: 
    # Updates report parameters
    api_response = api_instance.update_report_parameters(body, executionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionAPIApi->updateReportParameters: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionAsyncAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionAsyncAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionAsyncAPIApi apiInstance = new ReportJasperExecutionAsyncAPIApi();
        HvlJasperReportExecuteModel body = ; // HvlJasperReportExecuteModel | 
        try {
            HvlResponseHvlJasperReportExecutionModel result = apiInstance.asyncExecute(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAsyncAPIApi#asyncExecute");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionAsyncAPIApi;

public class ReportJasperExecutionAsyncAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionAsyncAPIApi apiInstance = new ReportJasperExecutionAsyncAPIApi();
        HvlJasperReportExecuteModel body = ; // HvlJasperReportExecuteModel | 
        try {
            HvlResponseHvlJasperReportExecutionModel result = apiInstance.asyncExecute(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAsyncAPIApi#asyncExecute");
            e.printStackTrace();
        }
    }
}

HvlJasperReportExecuteModel *body = ; // 

ReportJasperExecutionAsyncAPIApi *apiInstance = [[ReportJasperExecutionAsyncAPIApi alloc] init];

// Executes a report as asyncronized
[apiInstance asyncExecuteWith:body
              completionHandler: ^(HvlResponseHvlJasperReportExecutionModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionAsyncAPIApi()
var body = ; // {{HvlJasperReportExecuteModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.asyncExecute(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class asyncExecuteExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionAsyncAPIApi();
            var body = new HvlJasperReportExecuteModel(); // HvlJasperReportExecuteModel | 

            try
            {
                // Executes a report as asyncronized
                HvlResponseHvlJasperReportExecutionModel result = apiInstance.asyncExecute(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionAsyncAPIApi.asyncExecute: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionAsyncAPIApi();
$body = ; // HvlJasperReportExecuteModel | 

try {
    $result = $api_instance->asyncExecute($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionAsyncAPIApi->asyncExecute: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionAsyncAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionAsyncAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlJasperReportExecuteModel->new(); # HvlJasperReportExecuteModel | 

eval { 
    my $result = $api_instance->asyncExecute(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionAsyncAPIApi->asyncExecute: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionAsyncAPIApi()
body =  # HvlJasperReportExecuteModel | 

try: 
    # Executes a report as asyncronized
    api_response = api_instance.async_execute(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionAsyncAPIApi->asyncExecute: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionAsyncAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionAsyncAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionAsyncAPIApi apiInstance = new ReportJasperExecutionAsyncAPIApi();
        HvlJasperReportFileSystemOutputModel body = ; // HvlJasperReportFileSystemOutputModel | 
        try {
            array[byte[]] result = apiInstance.getOutputFromFileSystem(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAsyncAPIApi#getOutputFromFileSystem");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionAsyncAPIApi;

public class ReportJasperExecutionAsyncAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionAsyncAPIApi apiInstance = new ReportJasperExecutionAsyncAPIApi();
        HvlJasperReportFileSystemOutputModel body = ; // HvlJasperReportFileSystemOutputModel | 
        try {
            array[byte[]] result = apiInstance.getOutputFromFileSystem(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionAsyncAPIApi#getOutputFromFileSystem");
            e.printStackTrace();
        }
    }
}

HvlJasperReportFileSystemOutputModel *body = ; // 

ReportJasperExecutionAsyncAPIApi *apiInstance = [[ReportJasperExecutionAsyncAPIApi alloc] init];

// Gets report getOutputFromFileSystem
[apiInstance getOutputFromFileSystemWith:body
              completionHandler: ^(array[byte[]] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionAsyncAPIApi()
var body = ; // {{HvlJasperReportFileSystemOutputModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getOutputFromFileSystem(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getOutputFromFileSystemExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionAsyncAPIApi();
            var body = new HvlJasperReportFileSystemOutputModel(); // HvlJasperReportFileSystemOutputModel | 

            try
            {
                // Gets report getOutputFromFileSystem
                array[byte[]] result = apiInstance.getOutputFromFileSystem(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionAsyncAPIApi.getOutputFromFileSystem: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionAsyncAPIApi();
$body = ; // HvlJasperReportFileSystemOutputModel | 

try {
    $result = $api_instance->getOutputFromFileSystem($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionAsyncAPIApi->getOutputFromFileSystem: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionAsyncAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionAsyncAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlJasperReportFileSystemOutputModel->new(); # HvlJasperReportFileSystemOutputModel | 

eval { 
    my $result = $api_instance->getOutputFromFileSystem(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionAsyncAPIApi->getOutputFromFileSystem: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionAsyncAPIApi()
body =  # HvlJasperReportFileSystemOutputModel | 

try: 
    # Gets report getOutputFromFileSystem
    api_response = api_instance.get_output_from_file_system(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionAsyncAPIApi->getOutputFromFileSystem: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionSyncAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionSyncAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionSyncAPIApi apiInstance = new ReportJasperExecutionSyncAPIApi();
        String executionId = executionId_example; // String | 
        String exportId = exportId_example; // String | 
        Boolean forDownload = true; // Boolean | 
        try {
            array[byte[]] result = apiInstance.getOutputForSync(executionId, exportId, forDownload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionSyncAPIApi#getOutputForSync");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionSyncAPIApi;

public class ReportJasperExecutionSyncAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionSyncAPIApi apiInstance = new ReportJasperExecutionSyncAPIApi();
        String executionId = executionId_example; // String | 
        String exportId = exportId_example; // String | 
        Boolean forDownload = true; // Boolean | 
        try {
            array[byte[]] result = apiInstance.getOutputForSync(executionId, exportId, forDownload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionSyncAPIApi#getOutputForSync");
            e.printStackTrace();
        }
    }
}

String *executionId = executionId_example; // 
String *exportId = exportId_example; // 
Boolean *forDownload = true; // 

ReportJasperExecutionSyncAPIApi *apiInstance = [[ReportJasperExecutionSyncAPIApi alloc] init];

// Gets report output
[apiInstance getOutputForSyncWith:executionId
    exportId:exportId
    forDownload:forDownload
              completionHandler: ^(array[byte[]] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionSyncAPIApi()
var executionId = executionId_example; // {{String}} 
var exportId = exportId_example; // {{String}} 
var forDownload = true; // {{Boolean}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getOutputForSync(executionId, exportId, forDownload, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getOutputForSyncExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionSyncAPIApi();
            var executionId = executionId_example;  // String | 
            var exportId = exportId_example;  // String | 
            var forDownload = true;  // Boolean | 

            try
            {
                // Gets report output
                array[byte[]] result = apiInstance.getOutputForSync(executionId, exportId, forDownload);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionSyncAPIApi.getOutputForSync: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionSyncAPIApi();
$executionId = executionId_example; // String | 
$exportId = exportId_example; // String | 
$forDownload = true; // Boolean | 

try {
    $result = $api_instance->getOutputForSync($executionId, $exportId, $forDownload);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionSyncAPIApi->getOutputForSync: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionSyncAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionSyncAPIApi->new();
my $executionId = executionId_example; # String | 
my $exportId = exportId_example; # String | 
my $forDownload = true; # Boolean | 

eval { 
    my $result = $api_instance->getOutputForSync(executionId => $executionId, exportId => $exportId, forDownload => $forDownload);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionSyncAPIApi->getOutputForSync: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionSyncAPIApi()
executionId = executionId_example # String | 
exportId = exportId_example # String | 
forDownload = true # Boolean | 

try: 
    # Gets report output
    api_response = api_instance.get_output_for_sync(executionId, exportId, forDownload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionSyncAPIApi->getOutputForSync: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionSyncAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionSyncAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionSyncAPIApi apiInstance = new ReportJasperExecutionSyncAPIApi();
        HvlJasperReportExecuteModel body = ; // HvlJasperReportExecuteModel | 
        try {
            HvlResponseHvlJasperReportExecutionModel result = apiInstance.syncExecute(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionSyncAPIApi#syncExecute");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionSyncAPIApi;

public class ReportJasperExecutionSyncAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionSyncAPIApi apiInstance = new ReportJasperExecutionSyncAPIApi();
        HvlJasperReportExecuteModel body = ; // HvlJasperReportExecuteModel | 
        try {
            HvlResponseHvlJasperReportExecutionModel result = apiInstance.syncExecute(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionSyncAPIApi#syncExecute");
            e.printStackTrace();
        }
    }
}

HvlJasperReportExecuteModel *body = ; // 

ReportJasperExecutionSyncAPIApi *apiInstance = [[ReportJasperExecutionSyncAPIApi alloc] init];

// Executes a report as syncronized
[apiInstance syncExecuteWith:body
              completionHandler: ^(HvlResponseHvlJasperReportExecutionModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionSyncAPIApi()
var body = ; // {{HvlJasperReportExecuteModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.syncExecute(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class syncExecuteExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionSyncAPIApi();
            var body = new HvlJasperReportExecuteModel(); // HvlJasperReportExecuteModel | 

            try
            {
                // Executes a report as syncronized
                HvlResponseHvlJasperReportExecutionModel result = apiInstance.syncExecute(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionSyncAPIApi.syncExecute: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionSyncAPIApi();
$body = ; // HvlJasperReportExecuteModel | 

try {
    $result = $api_instance->syncExecute($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionSyncAPIApi->syncExecute: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionSyncAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionSyncAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlJasperReportExecuteModel->new(); # HvlJasperReportExecuteModel | 

eval { 
    my $result = $api_instance->syncExecute(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionSyncAPIApi->syncExecute: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionSyncAPIApi()
body =  # HvlJasperReportExecuteModel | 

try: 
    # Executes a report as syncronized
    api_response = api_instance.sync_execute(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionSyncAPIApi->syncExecute: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionSyncAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionSyncAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionSyncAPIApi apiInstance = new ReportJasperExecutionSyncAPIApi();
        HvlJasperReportBeanExecuteModel body = ; // HvlJasperReportBeanExecuteModel | 
        Boolean forDownload = true; // Boolean | 
        try {
            array[byte[]] result = apiInstance.syncExecuteAndGetOutput(body, forDownload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionSyncAPIApi#syncExecuteAndGetOutput");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionSyncAPIApi;

public class ReportJasperExecutionSyncAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionSyncAPIApi apiInstance = new ReportJasperExecutionSyncAPIApi();
        HvlJasperReportBeanExecuteModel body = ; // HvlJasperReportBeanExecuteModel | 
        Boolean forDownload = true; // Boolean | 
        try {
            array[byte[]] result = apiInstance.syncExecuteAndGetOutput(body, forDownload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionSyncAPIApi#syncExecuteAndGetOutput");
            e.printStackTrace();
        }
    }
}

HvlJasperReportBeanExecuteModel *body = ; // 
Boolean *forDownload = true; // 

ReportJasperExecutionSyncAPIApi *apiInstance = [[ReportJasperExecutionSyncAPIApi alloc] init];

// Executes a report with java bean object as synchronized and returns data as byte array
[apiInstance syncExecuteAndGetOutputWith:body
    forDownload:forDownload
              completionHandler: ^(array[byte[]] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionSyncAPIApi()
var body = ; // {{HvlJasperReportBeanExecuteModel}} 
var forDownload = true; // {{Boolean}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.syncExecuteAndGetOutput(bodyforDownload, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class syncExecuteAndGetOutputExample
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionSyncAPIApi();
            var body = new HvlJasperReportBeanExecuteModel(); // HvlJasperReportBeanExecuteModel | 
            var forDownload = true;  // Boolean | 

            try
            {
                // Executes a report with java bean object as synchronized and returns data as byte array
                array[byte[]] result = apiInstance.syncExecuteAndGetOutput(body, forDownload);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionSyncAPIApi.syncExecuteAndGetOutput: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionSyncAPIApi();
$body = ; // HvlJasperReportBeanExecuteModel | 
$forDownload = true; // Boolean | 

try {
    $result = $api_instance->syncExecuteAndGetOutput($body, $forDownload);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionSyncAPIApi->syncExecuteAndGetOutput: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionSyncAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionSyncAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlJasperReportBeanExecuteModel->new(); # HvlJasperReportBeanExecuteModel | 
my $forDownload = true; # Boolean | 

eval { 
    my $result = $api_instance->syncExecuteAndGetOutput(body => $body, forDownload => $forDownload);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionSyncAPIApi->syncExecuteAndGetOutput: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionSyncAPIApi()
body =  # HvlJasperReportBeanExecuteModel | 
forDownload = true # Boolean | 

try: 
    # Executes a report with java bean object as synchronized and returns data as byte array
    api_response = api_instance.sync_execute_and_get_output(body, forDownload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionSyncAPIApi->syncExecuteAndGetOutput: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportJasperExecutionSyncAPIApi;

import java.io.File;
import java.util.*;

public class ReportJasperExecutionSyncAPIApiExample {

    public static void main(String[] args) {
        
        ReportJasperExecutionSyncAPIApi apiInstance = new ReportJasperExecutionSyncAPIApi();
        HvlJasperReportExecuteModel body = ; // HvlJasperReportExecuteModel | 
        Boolean forDownload = true; // Boolean | 
        try {
            array[byte[]] result = apiInstance.syncExecuteAndGetOutput1(body, forDownload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionSyncAPIApi#syncExecuteAndGetOutput1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportJasperExecutionSyncAPIApi;

public class ReportJasperExecutionSyncAPIApiExample {

    public static void main(String[] args) {
        ReportJasperExecutionSyncAPIApi apiInstance = new ReportJasperExecutionSyncAPIApi();
        HvlJasperReportExecuteModel body = ; // HvlJasperReportExecuteModel | 
        Boolean forDownload = true; // Boolean | 
        try {
            array[byte[]] result = apiInstance.syncExecuteAndGetOutput1(body, forDownload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportJasperExecutionSyncAPIApi#syncExecuteAndGetOutput1");
            e.printStackTrace();
        }
    }
}

HvlJasperReportExecuteModel *body = ; // 
Boolean *forDownload = true; // 

ReportJasperExecutionSyncAPIApi *apiInstance = [[ReportJasperExecutionSyncAPIApi alloc] init];

// Executes a report as syncronized and returns data as byte array
[apiInstance syncExecuteAndGetOutput1With:body
    forDownload:forDownload
              completionHandler: ^(array[byte[]] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportJasperExecutionSyncAPIApi()
var body = ; // {{HvlJasperReportExecuteModel}} 
var forDownload = true; // {{Boolean}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.syncExecuteAndGetOutput1(bodyforDownload, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class syncExecuteAndGetOutput1Example
    {
        public void main()
        {

            var apiInstance = new ReportJasperExecutionSyncAPIApi();
            var body = new HvlJasperReportExecuteModel(); // HvlJasperReportExecuteModel | 
            var forDownload = true;  // Boolean | 

            try
            {
                // Executes a report as syncronized and returns data as byte array
                array[byte[]] result = apiInstance.syncExecuteAndGetOutput1(body, forDownload);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportJasperExecutionSyncAPIApi.syncExecuteAndGetOutput1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportJasperExecutionSyncAPIApi();
$body = ; // HvlJasperReportExecuteModel | 
$forDownload = true; // Boolean | 

try {
    $result = $api_instance->syncExecuteAndGetOutput1($body, $forDownload);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportJasperExecutionSyncAPIApi->syncExecuteAndGetOutput1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportJasperExecutionSyncAPIApi;

my $api_instance = WWW::SwaggerClient::ReportJasperExecutionSyncAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlJasperReportExecuteModel->new(); # HvlJasperReportExecuteModel | 
my $forDownload = true; # Boolean | 

eval { 
    my $result = $api_instance->syncExecuteAndGetOutput1(body => $body, forDownload => $forDownload);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportJasperExecutionSyncAPIApi->syncExecuteAndGetOutput1: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportJasperExecutionSyncAPIApi()
body =  # HvlJasperReportExecuteModel | 
forDownload = true # Boolean | 

try: 
    # Executes a report as syncronized and returns data as byte array
    api_response = api_instance.sync_execute_and_get_output1(body, forDownload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportJasperExecutionSyncAPIApi->syncExecuteAndGetOutput1: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportOrderAPIApi;

import java.io.File;
import java.util.*;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        HvlRToolReportOrderExecutionModel body = ; // HvlRToolReportOrderExecutionModel | 
        try {
            byte[] result = apiInstance.callSyncExecution(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#callSyncExecution");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportOrderAPIApi;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        HvlRToolReportOrderExecutionModel body = ; // HvlRToolReportOrderExecutionModel | 
        try {
            byte[] result = apiInstance.callSyncExecution(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#callSyncExecution");
            e.printStackTrace();
        }
    }
}

HvlRToolReportOrderExecutionModel *body = ; // 

ReportOrderAPIApi *apiInstance = [[ReportOrderAPIApi alloc] init];

// Executes and export reports synchronously.
[apiInstance callSyncExecutionWith:body
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportOrderAPIApi()
var body = ; // {{HvlRToolReportOrderExecutionModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.callSyncExecution(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class callSyncExecutionExample
    {
        public void main()
        {

            var apiInstance = new ReportOrderAPIApi();
            var body = new HvlRToolReportOrderExecutionModel(); // HvlRToolReportOrderExecutionModel | 

            try
            {
                // Executes and export reports synchronously.
                byte[] result = apiInstance.callSyncExecution(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportOrderAPIApi.callSyncExecution: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportOrderAPIApi();
$body = ; // HvlRToolReportOrderExecutionModel | 

try {
    $result = $api_instance->callSyncExecution($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportOrderAPIApi->callSyncExecution: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportOrderAPIApi;

my $api_instance = WWW::SwaggerClient::ReportOrderAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolReportOrderExecutionModel->new(); # HvlRToolReportOrderExecutionModel | 

eval { 
    my $result = $api_instance->callSyncExecution(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportOrderAPIApi->callSyncExecution: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportOrderAPIApi()
body =  # HvlRToolReportOrderExecutionModel | 

try: 
    # Executes and export reports synchronously.
    api_response = api_instance.call_sync_execution(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportOrderAPIApi->callSyncExecution: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportOrderAPIApi;

import java.io.File;
import java.util.*;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseVoid result = apiInstance.deleteByUuid(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#deleteByUuid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportOrderAPIApi;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseVoid result = apiInstance.deleteByUuid(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#deleteByUuid");
            e.printStackTrace();
        }
    }
}

String *uuid = uuid_example; // 

ReportOrderAPIApi *apiInstance = [[ReportOrderAPIApi alloc] init];

// Deletes report order with provided uuid
[apiInstance deleteByUuidWith:uuid
              completionHandler: ^(HvlResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportOrderAPIApi()
var uuid = uuid_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteByUuid(uuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteByUuidExample
    {
        public void main()
        {

            var apiInstance = new ReportOrderAPIApi();
            var uuid = uuid_example;  // String | 

            try
            {
                // Deletes report order with provided uuid
                HvlResponseVoid result = apiInstance.deleteByUuid(uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportOrderAPIApi.deleteByUuid: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportOrderAPIApi();
$uuid = uuid_example; // String | 

try {
    $result = $api_instance->deleteByUuid($uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportOrderAPIApi->deleteByUuid: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportOrderAPIApi;

my $api_instance = WWW::SwaggerClient::ReportOrderAPIApi->new();
my $uuid = uuid_example; # String | 

eval { 
    my $result = $api_instance->deleteByUuid(uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportOrderAPIApi->deleteByUuid: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportOrderAPIApi()
uuid = uuid_example # String | 

try: 
    # Deletes report order with provided uuid
    api_response = api_instance.delete_by_uuid(uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportOrderAPIApi->deleteByUuid: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportOrderAPIApi;

import java.io.File;
import java.util.*;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseHvlRToolReportOrderModel result = apiInstance.getByUuid(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#getByUuid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportOrderAPIApi;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        String uuid = uuid_example; // String | 
        try {
            HvlResponseHvlRToolReportOrderModel result = apiInstance.getByUuid(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#getByUuid");
            e.printStackTrace();
        }
    }
}

String *uuid = uuid_example; // 

ReportOrderAPIApi *apiInstance = [[ReportOrderAPIApi alloc] init];

// Gets the report order with provided uuid
[apiInstance getByUuidWith:uuid
              completionHandler: ^(HvlResponseHvlRToolReportOrderModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportOrderAPIApi()
var uuid = uuid_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getByUuid(uuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getByUuidExample
    {
        public void main()
        {

            var apiInstance = new ReportOrderAPIApi();
            var uuid = uuid_example;  // String | 

            try
            {
                // Gets the report order with provided uuid
                HvlResponseHvlRToolReportOrderModel result = apiInstance.getByUuid(uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportOrderAPIApi.getByUuid: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportOrderAPIApi();
$uuid = uuid_example; // String | 

try {
    $result = $api_instance->getByUuid($uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportOrderAPIApi->getByUuid: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportOrderAPIApi;

my $api_instance = WWW::SwaggerClient::ReportOrderAPIApi->new();
my $uuid = uuid_example; # String | 

eval { 
    my $result = $api_instance->getByUuid(uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportOrderAPIApi->getByUuid: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportOrderAPIApi()
uuid = uuid_example # String | 

try: 
    # Gets the report order with provided uuid
    api_response = api_instance.get_by_uuid(uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportOrderAPIApi->getByUuid: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportOrderAPIApi;

import java.io.File;
import java.util.*;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        HvlRToolReportOrderQueryModel body = ; // HvlRToolReportOrderQueryModel | 
        try {
            HvlResponseListHvlRToolReportOrderDataModel result = apiInstance.queryDataList(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#queryDataList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportOrderAPIApi;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        HvlRToolReportOrderQueryModel body = ; // HvlRToolReportOrderQueryModel | 
        try {
            HvlResponseListHvlRToolReportOrderDataModel result = apiInstance.queryDataList(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#queryDataList");
            e.printStackTrace();
        }
    }
}

HvlRToolReportOrderQueryModel *body = ; // 

ReportOrderAPIApi *apiInstance = [[ReportOrderAPIApi alloc] init];

// Queries report orders according to criteria in query model
[apiInstance queryDataListWith:body
              completionHandler: ^(HvlResponseListHvlRToolReportOrderDataModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportOrderAPIApi()
var body = ; // {{HvlRToolReportOrderQueryModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.queryDataList(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class queryDataListExample
    {
        public void main()
        {

            var apiInstance = new ReportOrderAPIApi();
            var body = new HvlRToolReportOrderQueryModel(); // HvlRToolReportOrderQueryModel | 

            try
            {
                // Queries report orders according to criteria in query model
                HvlResponseListHvlRToolReportOrderDataModel result = apiInstance.queryDataList(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportOrderAPIApi.queryDataList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportOrderAPIApi();
$body = ; // HvlRToolReportOrderQueryModel | 

try {
    $result = $api_instance->queryDataList($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportOrderAPIApi->queryDataList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportOrderAPIApi;

my $api_instance = WWW::SwaggerClient::ReportOrderAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolReportOrderQueryModel->new(); # HvlRToolReportOrderQueryModel | 

eval { 
    my $result = $api_instance->queryDataList(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportOrderAPIApi->queryDataList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportOrderAPIApi()
body =  # HvlRToolReportOrderQueryModel | 

try: 
    # Queries report orders according to criteria in query model
    api_response = api_instance.query_data_list(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportOrderAPIApi->queryDataList: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportOrderAPIApi;

import java.io.File;
import java.util.*;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        HvlRToolReportOrderQueryModel body = ; // HvlRToolReportOrderQueryModel | 
        try {
            HvlResponseHvlPageHvlRToolReportOrderDataModel result = apiInstance.queryDataPage(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#queryDataPage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportOrderAPIApi;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        HvlRToolReportOrderQueryModel body = ; // HvlRToolReportOrderQueryModel | 
        try {
            HvlResponseHvlPageHvlRToolReportOrderDataModel result = apiInstance.queryDataPage(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#queryDataPage");
            e.printStackTrace();
        }
    }
}

HvlRToolReportOrderQueryModel *body = ; // 

ReportOrderAPIApi *apiInstance = [[ReportOrderAPIApi alloc] init];

// Queries report orders as paginated according to criteria in query model
[apiInstance queryDataPageWith:body
              completionHandler: ^(HvlResponseHvlPageHvlRToolReportOrderDataModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportOrderAPIApi()
var body = ; // {{HvlRToolReportOrderQueryModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.queryDataPage(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class queryDataPageExample
    {
        public void main()
        {

            var apiInstance = new ReportOrderAPIApi();
            var body = new HvlRToolReportOrderQueryModel(); // HvlRToolReportOrderQueryModel | 

            try
            {
                // Queries report orders as paginated according to criteria in query model
                HvlResponseHvlPageHvlRToolReportOrderDataModel result = apiInstance.queryDataPage(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportOrderAPIApi.queryDataPage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportOrderAPIApi();
$body = ; // HvlRToolReportOrderQueryModel | 

try {
    $result = $api_instance->queryDataPage($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportOrderAPIApi->queryDataPage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportOrderAPIApi;

my $api_instance = WWW::SwaggerClient::ReportOrderAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolReportOrderQueryModel->new(); # HvlRToolReportOrderQueryModel | 

eval { 
    my $result = $api_instance->queryDataPage(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportOrderAPIApi->queryDataPage: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportOrderAPIApi()
body =  # HvlRToolReportOrderQueryModel | 

try: 
    # Queries report orders as paginated according to criteria in query model
    api_response = api_instance.query_data_page(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportOrderAPIApi->queryDataPage: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportOrderAPIApi;

import java.io.File;
import java.util.*;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        HvlRToolReportOrderModel body = ; // HvlRToolReportOrderModel | 
        try {
            HvlResponseVoid result = apiInstance.save(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#save");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportOrderAPIApi;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        HvlRToolReportOrderModel body = ; // HvlRToolReportOrderModel | 
        try {
            HvlResponseVoid result = apiInstance.save(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#save");
            e.printStackTrace();
        }
    }
}

HvlRToolReportOrderModel *body = ; // 

ReportOrderAPIApi *apiInstance = [[ReportOrderAPIApi alloc] init];

// Saves report order
[apiInstance saveWith:body
              completionHandler: ^(HvlResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportOrderAPIApi()
var body = ; // {{HvlRToolReportOrderModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.save(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class saveExample
    {
        public void main()
        {

            var apiInstance = new ReportOrderAPIApi();
            var body = new HvlRToolReportOrderModel(); // HvlRToolReportOrderModel | 

            try
            {
                // Saves report order
                HvlResponseVoid result = apiInstance.save(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportOrderAPIApi.save: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportOrderAPIApi();
$body = ; // HvlRToolReportOrderModel | 

try {
    $result = $api_instance->save($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportOrderAPIApi->save: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportOrderAPIApi;

my $api_instance = WWW::SwaggerClient::ReportOrderAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolReportOrderModel->new(); # HvlRToolReportOrderModel | 

eval { 
    my $result = $api_instance->save(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportOrderAPIApi->save: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportOrderAPIApi()
body =  # HvlRToolReportOrderModel | 

try: 
    # Saves report order
    api_response = api_instance.save(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportOrderAPIApi->save: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportOrderAPIApi;

import java.io.File;
import java.util.*;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        HvlRToolReportOrderModel body = ; // HvlRToolReportOrderModel | 
        try {
            HvlResponseVoid result = apiInstance.update(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#update");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportOrderAPIApi;

public class ReportOrderAPIApiExample {

    public static void main(String[] args) {
        ReportOrderAPIApi apiInstance = new ReportOrderAPIApi();
        HvlRToolReportOrderModel body = ; // HvlRToolReportOrderModel | 
        try {
            HvlResponseVoid result = apiInstance.update(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportOrderAPIApi#update");
            e.printStackTrace();
        }
    }
}

HvlRToolReportOrderModel *body = ; // 

ReportOrderAPIApi *apiInstance = [[ReportOrderAPIApi alloc] init];

// Updates report order
[apiInstance updateWith:body
              completionHandler: ^(HvlResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HvlJasperReportServer = require('hvl_jasper_report_server');

var api = new HvlJasperReportServer.ReportOrderAPIApi()
var body = ; // {{HvlRToolReportOrderModel}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.update(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateExample
    {
        public void main()
        {

            var apiInstance = new ReportOrderAPIApi();
            var body = new HvlRToolReportOrderModel(); // HvlRToolReportOrderModel | 

            try
            {
                // Updates report order
                HvlResponseVoid result = apiInstance.update(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportOrderAPIApi.update: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReportOrderAPIApi();
$body = ; // HvlRToolReportOrderModel | 

try {
    $result = $api_instance->update($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReportOrderAPIApi->update: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportOrderAPIApi;

my $api_instance = WWW::SwaggerClient::ReportOrderAPIApi->new();
my $body = WWW::SwaggerClient::Object::HvlRToolReportOrderModel->new(); # HvlRToolReportOrderModel | 

eval { 
    my $result = $api_instance->update(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReportOrderAPIApi->update: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReportOrderAPIApi()
body =  # HvlRToolReportOrderModel | 

try: 
    # Updates report order
    api_response = api_instance.update(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReportOrderAPIApi->update: %s\n" % e)