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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addBareMetalComputeService_body body = ; // Simid_addBareMetalComputeService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addBareMetalComputeService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addBareMetalComputeService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addBareMetalComputeService_body body = ; // Simid_addBareMetalComputeService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addBareMetalComputeService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addBareMetalComputeService");
            e.printStackTrace();
        }
    }
}

Simid_addBareMetalComputeService_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation

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

// Create and start a bare-metal compute service.
[apiInstance addBareMetalComputeServiceWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_addBareMetalComputeService_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_addBareMetalComputeService_body(); // Simid_addBareMetalComputeService_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create and start a bare-metal compute service.
                ServiceResponse result = apiInstance.addBareMetalComputeService(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addBareMetalComputeService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_addBareMetalComputeService_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_addBareMetalComputeService_body->new(); # Simid_addBareMetalComputeService_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->addBareMetalComputeService(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addBareMetalComputeService: $@\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.WRENCHApi()
body =  # Simid_addBareMetalComputeService_body | Input to start a new service.
simid = simid_example # String | ID of the simulation

try: 
    # Create and start a bare-metal compute service.
    api_response = api_instance.add_bare_metal_compute_service(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addBareMetalComputeService: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addCloudComputeService_body body = ; // Simid_addCloudComputeService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addCloudComputeService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addCloudComputeService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addCloudComputeService_body body = ; // Simid_addCloudComputeService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addCloudComputeService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addCloudComputeService");
            e.printStackTrace();
        }
    }
}

Simid_addCloudComputeService_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation

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

// Create and start a cloud compute service.
[apiInstance addCloudComputeServiceWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_addCloudComputeService_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_addCloudComputeService_body(); // Simid_addCloudComputeService_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create and start a cloud compute service.
                ServiceResponse result = apiInstance.addCloudComputeService(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addCloudComputeService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_addCloudComputeService_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_addCloudComputeService_body->new(); # Simid_addCloudComputeService_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->addCloudComputeService(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addCloudComputeService: $@\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.WRENCHApi()
body =  # Simid_addCloudComputeService_body | Input to start a new service.
simid = simid_example # String | ID of the simulation

try: 
    # Create and start a cloud compute service.
    api_response = api_instance.add_cloud_compute_service(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addCloudComputeService: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addFile_body body = ; // Simid_addFile_body | Input to add a new file.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.addFile(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addFile_body body = ; // Simid_addFile_body | Input to add a new file.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.addFile(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFile");
            e.printStackTrace();
        }
    }
}

Simid_addFile_body *body = ; // Input to add a new file.
String *simid = simid_example; // ID of the simulation

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

// Add a file to the workflow.
[apiInstance addFileWith:body
    simid:simid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_addFile_body}} Input to add a new file.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_addFile_body(); // Simid_addFile_body | Input to add a new file.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Add a file to the workflow.
                GenericResponse result = apiInstance.addFile(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addFile: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_addFile_body | Input to add a new file.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_addFile_body->new(); # Simid_addFile_body | Input to add a new file.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->addFile(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addFile: $@\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.WRENCHApi()
body =  # Simid_addFile_body | Input to add a new file.
simid = simid_example # String | ID of the simulation

try: 
    # Add a file to the workflow.
    api_response = api_instance.add_file(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addFile: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addFileRegistryService_body body = ; // Simid_addFileRegistryService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addFileRegistryService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFileRegistryService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addFileRegistryService_body body = ; // Simid_addFileRegistryService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addFileRegistryService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFileRegistryService");
            e.printStackTrace();
        }
    }
}

Simid_addFileRegistryService_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation

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

// Create and start a file registery service.
[apiInstance addFileRegistryServiceWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_addFileRegistryService_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_addFileRegistryService_body(); // Simid_addFileRegistryService_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create and start a file registery service.
                ServiceResponse result = apiInstance.addFileRegistryService(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addFileRegistryService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_addFileRegistryService_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_addFileRegistryService_body->new(); # Simid_addFileRegistryService_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->addFileRegistryService(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addFileRegistryService: $@\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.WRENCHApi()
body =  # Simid_addFileRegistryService_body | Input to start a new service.
simid = simid_example # String | ID of the simulation

try: 
    # Create and start a file registery service.
    api_response = api_instance.add_file_registry_service(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addFileRegistryService: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Tid_addInputFile_body body = ; // Tid_addInputFile_body | Input file.
        String simid = simid_example; // String | ID of the simulation
        String tid = tid_example; // String | ID of the task
        try {
            GenericResponse result = apiInstance.addInputFile(body, simid, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addInputFile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Tid_addInputFile_body body = ; // Tid_addInputFile_body | Input file.
        String simid = simid_example; // String | ID of the simulation
        String tid = tid_example; // String | ID of the task
        try {
            GenericResponse result = apiInstance.addInputFile(body, simid, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addInputFile");
            e.printStackTrace();
        }
    }
}

Tid_addInputFile_body *body = ; // Input file.
String *simid = simid_example; // ID of the simulation
String *tid = tid_example; // ID of the task

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

// Add an input file to a task
[apiInstance addInputFileWith:body
    simid:simid
    tid:tid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Tid_addInputFile_body}} Input file.
var simid = simid_example; // {{String}} ID of the simulation
var tid = tid_example; // {{String}} ID of the task

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Tid_addInputFile_body(); // Tid_addInputFile_body | Input file.
            var simid = simid_example;  // String | ID of the simulation
            var tid = tid_example;  // String | ID of the task

            try
            {
                // Add an input file to a task
                GenericResponse result = apiInstance.addInputFile(body, simid, tid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addInputFile: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Tid_addInputFile_body | Input file.
$simid = simid_example; // String | ID of the simulation
$tid = tid_example; // String | ID of the task

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Tid_addInputFile_body->new(); # Tid_addInputFile_body | Input file.
my $simid = simid_example; # String | ID of the simulation
my $tid = tid_example; # String | ID of the task

eval { 
    my $result = $api_instance->addInputFile(body => $body, simid => $simid, tid => $tid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addInputFile: $@\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.WRENCHApi()
body =  # Tid_addInputFile_body | Input file.
simid = simid_example # String | ID of the simulation
tid = tid_example # String | ID of the task

try: 
    # Add an input file to a task
    api_response = api_instance.add_input_file(body, simid, tid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addInputFile: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Tid_addOutputFile_body body = ; // Tid_addOutputFile_body | Job characteristics.
        String simid = simid_example; // String | ID of the simulation
        String tid = tid_example; // String | ID of the task
        try {
            GenericResponse result = apiInstance.addOutputFile(body, simid, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addOutputFile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Tid_addOutputFile_body body = ; // Tid_addOutputFile_body | Job characteristics.
        String simid = simid_example; // String | ID of the simulation
        String tid = tid_example; // String | ID of the task
        try {
            GenericResponse result = apiInstance.addOutputFile(body, simid, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addOutputFile");
            e.printStackTrace();
        }
    }
}

Tid_addOutputFile_body *body = ; // Job characteristics.
String *simid = simid_example; // ID of the simulation
String *tid = tid_example; // ID of the task

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

// Add an output file to a task
[apiInstance addOutputFileWith:body
    simid:simid
    tid:tid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Tid_addOutputFile_body}} Job characteristics.
var simid = simid_example; // {{String}} ID of the simulation
var tid = tid_example; // {{String}} ID of the task

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Tid_addOutputFile_body(); // Tid_addOutputFile_body | Job characteristics.
            var simid = simid_example;  // String | ID of the simulation
            var tid = tid_example;  // String | ID of the task

            try
            {
                // Add an output file to a task
                GenericResponse result = apiInstance.addOutputFile(body, simid, tid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addOutputFile: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Tid_addOutputFile_body | Job characteristics.
$simid = simid_example; // String | ID of the simulation
$tid = tid_example; // String | ID of the task

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Tid_addOutputFile_body->new(); # Tid_addOutputFile_body | Job characteristics.
my $simid = simid_example; # String | ID of the simulation
my $tid = tid_example; # String | ID of the task

eval { 
    my $result = $api_instance->addOutputFile(body => $body, simid => $simid, tid => $tid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addOutputFile: $@\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.WRENCHApi()
body =  # Tid_addOutputFile_body | Job characteristics.
simid = simid_example # String | ID of the simulation
tid = tid_example # String | ID of the task

try: 
    # Add an output file to a task
    api_response = api_instance.add_output_file(body, simid, tid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addOutputFile: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addSimpleStorageService_body body = ; // Simid_addSimpleStorageService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addSimpleStorageService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addSimpleStorageService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addSimpleStorageService_body body = ; // Simid_addSimpleStorageService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addSimpleStorageService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addSimpleStorageService");
            e.printStackTrace();
        }
    }
}

Simid_addSimpleStorageService_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation

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

// Create and start a simple storage service.
[apiInstance addSimpleStorageServiceWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_addSimpleStorageService_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_addSimpleStorageService_body(); // Simid_addSimpleStorageService_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create and start a simple storage service.
                ServiceResponse result = apiInstance.addSimpleStorageService(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addSimpleStorageService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_addSimpleStorageService_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_addSimpleStorageService_body->new(); # Simid_addSimpleStorageService_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->addSimpleStorageService(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addSimpleStorageService: $@\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.WRENCHApi()
body =  # Simid_addSimpleStorageService_body | Input to start a new service.
simid = simid_example # String | ID of the simulation

try: 
    # Create and start a simple storage service.
    api_response = api_instance.add_simple_storage_service(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addSimpleStorageService: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_advanceTime_body body = ; // Simid_advanceTime_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.advanceTime(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#advanceTime");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_advanceTime_body body = ; // Simid_advanceTime_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.advanceTime(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#advanceTime");
            e.printStackTrace();
        }
    }
}

Simid_advanceTime_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation

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

// Retrieve the current simulated time.
[apiInstance advanceTimeWith:body
    simid:simid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_advanceTime_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_advanceTime_body(); // Simid_advanceTime_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Retrieve the current simulated time.
                GenericResponse result = apiInstance.advanceTime(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.advanceTime: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_advanceTime_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_advanceTime_body->new(); # Simid_advanceTime_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->advanceTime(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->advanceTime: $@\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.WRENCHApi()
body =  # Simid_advanceTime_body | Input to start a new service.
simid = simid_example # String | ID of the simulation

try: 
    # Retrieve the current simulated time.
    api_response = api_instance.advance_time(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->advanceTime: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Storage_service_name_createFileCopy_body body = ; // Storage_service_name_createFileCopy_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        String storageServiceName = storageServiceName_example; // String | The storage service's head host
        try {
            GenericResponse result = apiInstance.createFileCopyAtStorageService(body, simid, storageServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createFileCopyAtStorageService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Storage_service_name_createFileCopy_body body = ; // Storage_service_name_createFileCopy_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        String storageServiceName = storageServiceName_example; // String | The storage service's head host
        try {
            GenericResponse result = apiInstance.createFileCopyAtStorageService(body, simid, storageServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createFileCopyAtStorageService");
            e.printStackTrace();
        }
    }
}

Storage_service_name_createFileCopy_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation
String *storageServiceName = storageServiceName_example; // The storage service's head host

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

// Create, ex nihilo, a copy of a file copy at a storage service.
[apiInstance createFileCopyAtStorageServiceWith:body
    simid:simid
    storageServiceName:storageServiceName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Storage_service_name_createFileCopy_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation
var storageServiceName = storageServiceName_example; // {{String}} The storage service's head host

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Storage_service_name_createFileCopy_body(); // Storage_service_name_createFileCopy_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation
            var storageServiceName = storageServiceName_example;  // String | The storage service's head host

            try
            {
                // Create, ex nihilo, a copy of a file copy at a storage service.
                GenericResponse result = apiInstance.createFileCopyAtStorageService(body, simid, storageServiceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.createFileCopyAtStorageService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Storage_service_name_createFileCopy_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation
$storageServiceName = storageServiceName_example; // String | The storage service's head host

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Storage_service_name_createFileCopy_body->new(); # Storage_service_name_createFileCopy_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation
my $storageServiceName = storageServiceName_example; # String | The storage service's head host

eval { 
    my $result = $api_instance->createFileCopyAtStorageService(body => $body, simid => $simid, storageServiceName => $storageServiceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->createFileCopyAtStorageService: $@\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.WRENCHApi()
body =  # Storage_service_name_createFileCopy_body | Input to start a new service.
simid = simid_example # String | ID of the simulation
storageServiceName = storageServiceName_example # String | The storage service's head host

try: 
    # Create, ex nihilo, a copy of a file copy at a storage service.
    api_response = api_instance.create_file_copy_at_storage_service(body, simid, storageServiceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->createFileCopyAtStorageService: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        StandardJob body = ; // StandardJob | Job specification.
        String simid = simid_example; // String | ID of the simulation
        try {
            JobResponse result = apiInstance.createStandardJob(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createStandardJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        StandardJob body = ; // StandardJob | Job specification.
        String simid = simid_example; // String | ID of the simulation
        try {
            JobResponse result = apiInstance.createStandardJob(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createStandardJob");
            e.printStackTrace();
        }
    }
}

StandardJob *body = ; // Job specification.
String *simid = simid_example; // ID of the simulation

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

// Create a new standard job.
[apiInstance createStandardJobWith:body
    simid:simid
              completionHandler: ^(JobResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{StandardJob}} Job specification.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new StandardJob(); // StandardJob | Job specification.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create a new standard job.
                JobResponse result = apiInstance.createStandardJob(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.createStandardJob: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // StandardJob | Job specification.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::StandardJob->new(); # StandardJob | Job specification.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->createStandardJob(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->createStandardJob: $@\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.WRENCHApi()
body =  # StandardJob | Job specification.
simid = simid_example # String | ID of the simulation

try: 
    # Create a new standard job.
    api_response = api_instance.create_standard_job(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->createStandardJob: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Task body = ; // Task | Task characteristics.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.createTask(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createTask");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Task body = ; // Task | Task characteristics.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.createTask(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createTask");
            e.printStackTrace();
        }
    }
}

Task *body = ; // Task characteristics.
String *simid = simid_example; // ID of the simulation

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

// Create a new task.
[apiInstance createTaskWith:body
    simid:simid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Task}} Task characteristics.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Task(); // Task | Task characteristics.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create a new task.
                GenericResponse result = apiInstance.createTask(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.createTask: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Task | Task characteristics.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Task->new(); # Task | Task characteristics.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->createTask(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->createTask: $@\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.WRENCHApi()
body =  # Task | Task characteristics.
simid = simid_example # String | ID of the simulation

try: 
    # Create a new task.
    api_response = api_instance.create_task(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->createTask: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_createVM_body body = ; // Simid_createVM_body | Input to start create a VM.
        String simid = simid_example; // String | ID of the simulation
        try {
            VMCreationResponse result = apiInstance.createVM(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createVM");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_createVM_body body = ; // Simid_createVM_body | Input to start create a VM.
        String simid = simid_example; // String | ID of the simulation
        try {
            VMCreationResponse result = apiInstance.createVM(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createVM");
            e.printStackTrace();
        }
    }
}

Simid_createVM_body *body = ; // Input to start create a VM.
String *simid = simid_example; // ID of the simulation

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

// Create a VM on a cloud compute service.
[apiInstance createVMWith:body
    simid:simid
              completionHandler: ^(VMCreationResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_createVM_body}} Input to start create a VM.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_createVM_body(); // Simid_createVM_body | Input to start create a VM.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create a VM on a cloud compute service.
                VMCreationResponse result = apiInstance.createVM(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.createVM: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_createVM_body | Input to start create a VM.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_createVM_body->new(); # Simid_createVM_body | Input to start create a VM.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->createVM(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->createVM: $@\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.WRENCHApi()
body =  # Simid_createVM_body | Input to start create a VM.
simid = simid_example # String | ID of the simulation

try: 
    # Create a VM on a cloud compute service.
    api_response = api_instance.create_vm(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->createVM: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_destroyVM_body body = ; // Simid_destroyVM_body | Input to destroy a VM.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.destroyVM(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#destroyVM");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_destroyVM_body body = ; // Simid_destroyVM_body | Input to destroy a VM.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.destroyVM(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#destroyVM");
            e.printStackTrace();
        }
    }
}

Simid_destroyVM_body *body = ; // Input to destroy a VM.
String *simid = simid_example; // ID of the simulation

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

// Destroy a VM.
[apiInstance destroyVMWith:body
    simid:simid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_destroyVM_body}} Input to destroy a VM.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_destroyVM_body(); // Simid_destroyVM_body | Input to destroy a VM.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Destroy a VM.
                GenericResponse result = apiInstance.destroyVM(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.destroyVM: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_destroyVM_body | Input to destroy a VM.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_destroyVM_body->new(); # Simid_destroyVM_body | Input to destroy a VM.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->destroyVM(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->destroyVM: $@\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.WRENCHApi()
body =  # Simid_destroyVM_body | Input to destroy a VM.
simid = simid_example # String | ID of the simulation

try: 
    # Destroy a VM.
    api_response = api_instance.destroy_vm(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->destroyVM: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of simulation
        try {
            HostnameList result = apiInstance.getAllHostnames(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getAllHostnames");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of simulation
        try {
            HostnameList result = apiInstance.getAllHostnames(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getAllHostnames");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of simulation

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

// Retrieve the names of all hosts in the simulated platform.
[apiInstance getAllHostnamesWith:simid
              completionHandler: ^(HostnameList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of simulation

            try
            {
                // Retrieve the names of all hosts in the simulated platform.
                HostnameList result = apiInstance.getAllHostnames(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getAllHostnames: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of simulation

eval { 
    my $result = $api_instance->getAllHostnames(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getAllHostnames: $@\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.WRENCHApi()
simid = simid_example # String | ID of simulation

try: 
    # Retrieve the names of all hosts in the simulated platform.
    api_response = api_instance.get_all_hostnames(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getAllHostnames: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String fileId = fileId_example; // String | Name of the file
        try {
            FileSizeResponse result = apiInstance.getFileSize(simid, fileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getFileSize");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String fileId = fileId_example; // String | Name of the file
        try {
            FileSizeResponse result = apiInstance.getFileSize(simid, fileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getFileSize");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation
String *fileId = fileId_example; // Name of the file

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

// Get a file size.
[apiInstance getFileSizeWith:simid
    fileId:fileId
              completionHandler: ^(FileSizeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var fileId = fileId_example; // {{String}} Name of the file

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var fileId = fileId_example;  // String | Name of the file

            try
            {
                // Get a file size.
                FileSizeResponse result = apiInstance.getFileSize(simid, fileId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getFileSize: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$fileId = fileId_example; // String | Name of the file

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $fileId = fileId_example; # String | Name of the file

eval { 
    my $result = $api_instance->getFileSize(simid => $simid, fileId => $fileId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getFileSize: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation
fileId = fileId_example # String | Name of the file

try: 
    # Get a file size.
    api_response = api_instance.get_file_size(simid, fileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getFileSize: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            FileList result = apiInstance.getInputFiles(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getInputFiles");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            FileList result = apiInstance.getInputFiles(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getInputFiles");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation

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

// Return the list of input files of the workflow.
[apiInstance getInputFilesWith:simid
              completionHandler: ^(FileList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Return the list of input files of the workflow.
                FileList result = apiInstance.getInputFiles(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getInputFiles: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->getInputFiles(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getInputFiles: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation

try: 
    # Return the list of input files of the workflow.
    api_response = api_instance.get_input_files(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getInputFiles: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of simulation
        try {
            EventList result = apiInstance.getSimulationEvents(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getSimulationEvents");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of simulation
        try {
            EventList result = apiInstance.getSimulationEvents(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getSimulationEvents");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of simulation

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

// Retrieve all simulation events since last time we checked.
[apiInstance getSimulationEventsWith:simid
              completionHandler: ^(EventList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of simulation

            try
            {
                // Retrieve all simulation events since last time we checked.
                EventList result = apiInstance.getSimulationEvents(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getSimulationEvents: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of simulation

eval { 
    my $result = $api_instance->getSimulationEvents(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getSimulationEvents: $@\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.WRENCHApi()
simid = simid_example # String | ID of simulation

try: 
    # Retrieve all simulation events since last time we checked.
    api_response = api_instance.get_simulation_events(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getSimulationEvents: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            TimeResponse result = apiInstance.getSimulationTime(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getSimulationTime");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            TimeResponse result = apiInstance.getSimulationTime(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getSimulationTime");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation

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

// Retrieve the current simulated time.
[apiInstance getSimulationTimeWith:simid
              completionHandler: ^(TimeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Retrieve the current simulated time.
                TimeResponse result = apiInstance.getSimulationTime(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getSimulationTime: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->getSimulationTime(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getSimulationTime: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation

try: 
    # Retrieve the current simulated time.
    api_response = api_instance.get_simulation_time(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getSimulationTime: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String jobName = jobName_example; // String | ID of the job
        try {
            TaskList result = apiInstance.getStandardJobTasks(simid, jobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getStandardJobTasks");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String jobName = jobName_example; // String | ID of the job
        try {
            TaskList result = apiInstance.getStandardJobTasks(simid, jobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getStandardJobTasks");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation
String *jobName = jobName_example; // ID of the job

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

// Retrieve job's tasks
[apiInstance getStandardJobTasksWith:simid
    jobName:jobName
              completionHandler: ^(TaskList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var jobName = jobName_example; // {{String}} ID of the job

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var jobName = jobName_example;  // String | ID of the job

            try
            {
                // Retrieve job's tasks
                TaskList result = apiInstance.getStandardJobTasks(simid, jobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getStandardJobTasks: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$jobName = jobName_example; // String | ID of the job

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $jobName = jobName_example; # String | ID of the job

eval { 
    my $result = $api_instance->getStandardJobTasks(simid => $simid, jobName => $jobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getStandardJobTasks: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation
jobName = jobName_example # String | ID of the job

try: 
    # Retrieve job's tasks
    api_response = api_instance.get_standard_job_tasks(simid, jobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getStandardJobTasks: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String name = name_example; // String | ID of the task
        try {
            TimeResponse result = apiInstance.getTaskEndDate(simid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskEndDate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String name = name_example; // String | ID of the task
        try {
            TimeResponse result = apiInstance.getTaskEndDate(simid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskEndDate");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation
String *name = name_example; // ID of the task

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

// Get a task's end date.
[apiInstance getTaskEndDateWith:simid
    name:name
              completionHandler: ^(TimeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var name = name_example; // {{String}} ID of the task

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var name = name_example;  // String | ID of the task

            try
            {
                // Get a task's end date.
                TimeResponse result = apiInstance.getTaskEndDate(simid, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskEndDate: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$name = name_example; // String | ID of the task

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $name = name_example; # String | ID of the task

eval { 
    my $result = $api_instance->getTaskEndDate(simid => $simid, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskEndDate: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation
name = name_example # String | ID of the task

try: 
    # Get a task's end date.
    api_response = api_instance.get_task_end_date(simid, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskEndDate: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String name = name_example; // String | ID of the task
        try {
            TaskFlops result = apiInstance.getTaskFlops(simid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String name = name_example; // String | ID of the task
        try {
            TaskFlops result = apiInstance.getTaskFlops(simid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation
String *name = name_example; // ID of the task

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

// Get a task's flops
[apiInstance getTaskFlopsWith:simid
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var name = name_example; // {{String}} ID of the task

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var name = name_example;  // String | ID of the task

            try
            {
                // Get a task's flops
                TaskFlops result = apiInstance.getTaskFlops(simid, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$name = name_example; // String | ID of the task

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $name = name_example; # String | ID of the task

eval { 
    my $result = $api_instance->getTaskFlops(simid => $simid, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation
name = name_example # String | ID of the task

try: 
    # Get a task's flops
    api_response = api_instance.get_task_flops(simid, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String tid = tid_example; // String | ID of the task
        try {
            FileList result = apiInstance.getTaskInputFiles(simid, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskInputFiles");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String tid = tid_example; // String | ID of the task
        try {
            FileList result = apiInstance.getTaskInputFiles(simid, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskInputFiles");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation
String *tid = tid_example; // ID of the task

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

// Retrieve task's input files
[apiInstance getTaskInputFilesWith:simid
    tid:tid
              completionHandler: ^(FileList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var tid = tid_example; // {{String}} ID of the task

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var tid = tid_example;  // String | ID of the task

            try
            {
                // Retrieve task's input files
                FileList result = apiInstance.getTaskInputFiles(simid, tid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskInputFiles: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$tid = tid_example; // String | ID of the task

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $tid = tid_example; # String | ID of the task

eval { 
    my $result = $api_instance->getTaskInputFiles(simid => $simid, tid => $tid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskInputFiles: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation
tid = tid_example # String | ID of the task

try: 
    # Retrieve task's input files
    api_response = api_instance.get_task_input_files(simid, tid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskInputFiles: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String name = name_example; // String | ID of the task
        try {
            TaskCores result = apiInstance.getTaskMaxNumCores(simid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMaxNumCores");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String name = name_example; // String | ID of the task
        try {
            TaskCores result = apiInstance.getTaskMaxNumCores(simid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMaxNumCores");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation
String *name = name_example; // ID of the task

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

// Get a task's maximum number of cores.
[apiInstance getTaskMaxNumCoresWith:simid
    name:name
              completionHandler: ^(TaskCores output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var name = name_example; // {{String}} ID of the task

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var name = name_example;  // String | ID of the task

            try
            {
                // Get a task's maximum number of cores.
                TaskCores result = apiInstance.getTaskMaxNumCores(simid, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskMaxNumCores: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$name = name_example; // String | ID of the task

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $name = name_example; # String | ID of the task

eval { 
    my $result = $api_instance->getTaskMaxNumCores(simid => $simid, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskMaxNumCores: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation
name = name_example # String | ID of the task

try: 
    # Get a task's maximum number of cores.
    api_response = api_instance.get_task_max_num_cores(simid, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskMaxNumCores: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String name = name_example; // String | ID of the task
        try {
            TaskMem result = apiInstance.getTaskMemory(simid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMemory");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String name = name_example; // String | ID of the task
        try {
            TaskMem result = apiInstance.getTaskMemory(simid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMemory");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation
String *name = name_example; // ID of the task

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

// Get a task's memory requirement.
[apiInstance getTaskMemoryWith:simid
    name:name
              completionHandler: ^(TaskMem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var name = name_example; // {{String}} ID of the task

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var name = name_example;  // String | ID of the task

            try
            {
                // Get a task's memory requirement.
                TaskMem result = apiInstance.getTaskMemory(simid, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskMemory: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$name = name_example; // String | ID of the task

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $name = name_example; # String | ID of the task

eval { 
    my $result = $api_instance->getTaskMemory(simid => $simid, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskMemory: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation
name = name_example # String | ID of the task

try: 
    # Get a task's memory requirement.
    api_response = api_instance.get_task_memory(simid, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskMemory: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String name = name_example; // String | ID of the task
        try {
            TaskCores result = apiInstance.getTaskMinNumCores(simid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMinNumCores");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String name = name_example; // String | ID of the task
        try {
            TaskCores result = apiInstance.getTaskMinNumCores(simid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMinNumCores");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation
String *name = name_example; // ID of the task

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

// Get a task's minimum number of cores.
[apiInstance getTaskMinNumCoresWith:simid
    name:name
              completionHandler: ^(TaskCores output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var name = name_example; // {{String}} ID of the task

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var name = name_example;  // String | ID of the task

            try
            {
                // Get a task's minimum number of cores.
                TaskCores result = apiInstance.getTaskMinNumCores(simid, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskMinNumCores: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$name = name_example; // String | ID of the task

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $name = name_example; # String | ID of the task

eval { 
    my $result = $api_instance->getTaskMinNumCores(simid => $simid, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskMinNumCores: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation
name = name_example # String | ID of the task

try: 
    # Get a task's minimum number of cores.
    api_response = api_instance.get_task_min_num_cores(simid, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskMinNumCores: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String tid = tid_example; // String | ID of the task
        try {
            FileList result = apiInstance.getTaskOutputFiles(simid, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskOutputFiles");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String tid = tid_example; // String | ID of the task
        try {
            FileList result = apiInstance.getTaskOutputFiles(simid, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskOutputFiles");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation
String *tid = tid_example; // ID of the task

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

// Retrieve task's output files
[apiInstance getTaskOutputFilesWith:simid
    tid:tid
              completionHandler: ^(FileList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var tid = tid_example; // {{String}} ID of the task

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var tid = tid_example;  // String | ID of the task

            try
            {
                // Retrieve task's output files
                FileList result = apiInstance.getTaskOutputFiles(simid, tid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskOutputFiles: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$tid = tid_example; // String | ID of the task

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $tid = tid_example; # String | ID of the task

eval { 
    my $result = $api_instance->getTaskOutputFiles(simid => $simid, tid => $tid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskOutputFiles: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation
tid = tid_example # String | ID of the task

try: 
    # Retrieve task's output files
    api_response = api_instance.get_task_output_files(simid, tid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskOutputFiles: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String name = name_example; // String | ID of the task
        try {
            TimeResponse result = apiInstance.getTaskStartDate(simid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskStartDate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String name = name_example; // String | ID of the task
        try {
            TimeResponse result = apiInstance.getTaskStartDate(simid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskStartDate");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation
String *name = name_example; // ID of the task

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

// Get a task's start date.
[apiInstance getTaskStartDateWith:simid
    name:name
              completionHandler: ^(TimeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var name = name_example; // {{String}} ID of the task

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var name = name_example;  // String | ID of the task

            try
            {
                // Get a task's start date.
                TimeResponse result = apiInstance.getTaskStartDate(simid, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskStartDate: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$name = name_example; // String | ID of the task

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $name = name_example; # String | ID of the task

eval { 
    my $result = $api_instance->getTaskStartDate(simid => $simid, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskStartDate: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation
name = name_example # String | ID of the task

try: 
    # Get a task's start date.
    api_response = api_instance.get_task_start_date(simid, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskStartDate: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_isVMDown_body body = ; // Simid_isVMDown_body | Input to check if VM is down.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.isVMDown(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#isVMDown");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_isVMDown_body body = ; // Simid_isVMDown_body | Input to check if VM is down.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.isVMDown(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#isVMDown");
            e.printStackTrace();
        }
    }
}

Simid_isVMDown_body *body = ; // Input to check if VM is down.
String *simid = simid_example; // ID of the simulation

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

// Method to check whether a VM is currently down.
[apiInstance isVMDownWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_isVMDown_body}} Input to check if VM is down.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_isVMDown_body(); // Simid_isVMDown_body | Input to check if VM is down.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Method to check whether a VM is currently down.
                ServiceResponse result = apiInstance.isVMDown(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.isVMDown: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_isVMDown_body | Input to check if VM is down.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_isVMDown_body->new(); # Simid_isVMDown_body | Input to check if VM is down.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->isVMDown(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->isVMDown: $@\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.WRENCHApi()
body =  # Simid_isVMDown_body | Input to check if VM is down.
simid = simid_example # String | ID of the simulation

try: 
    # Method to check whether a VM is currently down.
    api_response = api_instance.is_vm_down(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->isVMDown: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_isVMRunning_body body = ; // Simid_isVMRunning_body | Input to check if VM is running.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.isVMRunning(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#isVMRunning");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_isVMRunning_body body = ; // Simid_isVMRunning_body | Input to check if VM is running.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.isVMRunning(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#isVMRunning");
            e.printStackTrace();
        }
    }
}

Simid_isVMRunning_body *body = ; // Input to check if VM is running.
String *simid = simid_example; // ID of the simulation

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

// Method to check whether a VM is currently running.
[apiInstance isVMRunningWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_isVMRunning_body}} Input to check if VM is running.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_isVMRunning_body(); // Simid_isVMRunning_body | Input to check if VM is running.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Method to check whether a VM is currently running.
                ServiceResponse result = apiInstance.isVMRunning(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.isVMRunning: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_isVMRunning_body | Input to check if VM is running.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_isVMRunning_body->new(); # Simid_isVMRunning_body | Input to check if VM is running.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->isVMRunning(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->isVMRunning: $@\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.WRENCHApi()
body =  # Simid_isVMRunning_body | Input to check if VM is running.
simid = simid_example # String | ID of the simulation

try: 
    # Method to check whether a VM is currently running.
    api_response = api_instance.is_vm_running(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->isVMRunning: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_isVMSuspended_body body = ; // Simid_isVMSuspended_body | Input to check if VM is suspended.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.isVMSuspended(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#isVMSuspended");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_isVMSuspended_body body = ; // Simid_isVMSuspended_body | Input to check if VM is suspended.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.isVMSuspended(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#isVMSuspended");
            e.printStackTrace();
        }
    }
}

Simid_isVMSuspended_body *body = ; // Input to check if VM is suspended.
String *simid = simid_example; // ID of the simulation

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

// Method to check whether a VM is currently suspended.
[apiInstance isVMSuspendedWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_isVMSuspended_body}} Input to check if VM is suspended.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_isVMSuspended_body(); // Simid_isVMSuspended_body | Input to check if VM is suspended.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Method to check whether a VM is currently suspended.
                ServiceResponse result = apiInstance.isVMSuspended(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.isVMSuspended: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_isVMSuspended_body | Input to check if VM is suspended.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_isVMSuspended_body->new(); # Simid_isVMSuspended_body | Input to check if VM is suspended.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->isVMSuspended(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->isVMSuspended: $@\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.WRENCHApi()
body =  # Simid_isVMSuspended_body | Input to check if VM is suspended.
simid = simid_example # String | ID of the simulation

try: 
    # Method to check whether a VM is currently suspended.
    api_response = api_instance.is_vm_suspended(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->isVMSuspended: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Storage_service_name_lookupFile_body body = ; // Storage_service_name_lookupFile_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        String storageServiceName = storageServiceName_example; // String | The storage service's head host
        try {
            BooleanResponse result = apiInstance.lookupFileAtStorageService(body, simid, storageServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#lookupFileAtStorageService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Storage_service_name_lookupFile_body body = ; // Storage_service_name_lookupFile_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        String storageServiceName = storageServiceName_example; // String | The storage service's head host
        try {
            BooleanResponse result = apiInstance.lookupFileAtStorageService(body, simid, storageServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#lookupFileAtStorageService");
            e.printStackTrace();
        }
    }
}

Storage_service_name_lookupFile_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation
String *storageServiceName = storageServiceName_example; // The storage service's head host

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

// Check if a copy of a file is stored at a storage service.
[apiInstance lookupFileAtStorageServiceWith:body
    simid:simid
    storageServiceName:storageServiceName
              completionHandler: ^(BooleanResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Storage_service_name_lookupFile_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation
var storageServiceName = storageServiceName_example; // {{String}} The storage service's head host

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Storage_service_name_lookupFile_body(); // Storage_service_name_lookupFile_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation
            var storageServiceName = storageServiceName_example;  // String | The storage service's head host

            try
            {
                // Check if a copy of a file is stored at a storage service.
                BooleanResponse result = apiInstance.lookupFileAtStorageService(body, simid, storageServiceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.lookupFileAtStorageService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Storage_service_name_lookupFile_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation
$storageServiceName = storageServiceName_example; // String | The storage service's head host

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Storage_service_name_lookupFile_body->new(); # Storage_service_name_lookupFile_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation
my $storageServiceName = storageServiceName_example; # String | The storage service's head host

eval { 
    my $result = $api_instance->lookupFileAtStorageService(body => $body, simid => $simid, storageServiceName => $storageServiceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->lookupFileAtStorageService: $@\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.WRENCHApi()
body =  # Storage_service_name_lookupFile_body | Input to start a new service.
simid = simid_example # String | ID of the simulation
storageServiceName = storageServiceName_example # String | The storage service's head host

try: 
    # Check if a copy of a file is stored at a storage service.
    api_response = api_instance.lookup_file_at_storage_service(body, simid, storageServiceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->lookupFileAtStorageService: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_resumeVM_body body = ; // Simid_resumeVM_body | Input to resume a VM.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.resumeVM(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#resumeVM");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_resumeVM_body body = ; // Simid_resumeVM_body | Input to resume a VM.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.resumeVM(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#resumeVM");
            e.printStackTrace();
        }
    }
}

Simid_resumeVM_body *body = ; // Input to resume a VM.
String *simid = simid_example; // ID of the simulation

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

// Resume a suspended VM.
[apiInstance resumeVMWith:body
    simid:simid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_resumeVM_body}} Input to resume a VM.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_resumeVM_body(); // Simid_resumeVM_body | Input to resume a VM.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Resume a suspended VM.
                GenericResponse result = apiInstance.resumeVM(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.resumeVM: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_resumeVM_body | Input to resume a VM.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_resumeVM_body->new(); # Simid_resumeVM_body | Input to resume a VM.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->resumeVM(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->resumeVM: $@\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.WRENCHApi()
body =  # Simid_resumeVM_body | Input to resume a VM.
simid = simid_example # String | ID of the simulation

try: 
    # Resume a suspended VM.
    api_response = api_instance.resume_vm(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->resumeVM: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_shutdownVM_body body = ; // Simid_shutdownVM_body | Input to shutdown a VM.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.shutdownVM(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#shutdownVM");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_shutdownVM_body body = ; // Simid_shutdownVM_body | Input to shutdown a VM.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.shutdownVM(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#shutdownVM");
            e.printStackTrace();
        }
    }
}

Simid_shutdownVM_body *body = ; // Input to shutdown a VM.
String *simid = simid_example; // ID of the simulation

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

// Shutdown a VM.
[apiInstance shutdownVMWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_shutdownVM_body}} Input to shutdown a VM.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_shutdownVM_body(); // Simid_shutdownVM_body | Input to shutdown a VM.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Shutdown a VM.
                ServiceResponse result = apiInstance.shutdownVM(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.shutdownVM: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_shutdownVM_body | Input to shutdown a VM.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_shutdownVM_body->new(); # Simid_shutdownVM_body | Input to shutdown a VM.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->shutdownVM(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->shutdownVM: $@\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.WRENCHApi()
body =  # Simid_shutdownVM_body | Input to shutdown a VM.
simid = simid_example # String | ID of the simulation

try: 
    # Shutdown a VM.
    api_response = api_instance.shutdown_vm(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->shutdownVM: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        SimulationInput body = ; // SimulationInput | Start a new simulation based on a platform file and a controller hostname.
        try {
            SimulationReturn result = apiInstance.startSimulation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#startSimulation");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        SimulationInput body = ; // SimulationInput | Start a new simulation based on a platform file and a controller hostname.
        try {
            SimulationReturn result = apiInstance.startSimulation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#startSimulation");
            e.printStackTrace();
        }
    }
}

SimulationInput *body = ; // Start a new simulation based on a platform file and a controller hostname.

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

// Start a new simulation
[apiInstance startSimulationWith:body
              completionHandler: ^(SimulationReturn output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{SimulationInput}} Start a new simulation based on a platform file and a controller hostname.

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new SimulationInput(); // SimulationInput | Start a new simulation based on a platform file and a controller hostname.

            try
            {
                // Start a new simulation
                SimulationReturn result = apiInstance.startSimulation(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.startSimulation: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // SimulationInput | Start a new simulation based on a platform file and a controller hostname.

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::SimulationInput->new(); # SimulationInput | Start a new simulation based on a platform file and a controller hostname.

eval { 
    my $result = $api_instance->startSimulation(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->startSimulation: $@\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.WRENCHApi()
body =  # SimulationInput | Start a new simulation based on a platform file and a controller hostname.

try: 
    # Start a new simulation
    api_response = api_instance.start_simulation(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->startSimulation: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_startVM_body body = ; // Simid_startVM_body | Input to start a VM.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.startVM(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#startVM");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_startVM_body body = ; // Simid_startVM_body | Input to start a VM.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.startVM(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#startVM");
            e.printStackTrace();
        }
    }
}

Simid_startVM_body *body = ; // Input to start a VM.
String *simid = simid_example; // ID of the simulation

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

// Starts a VM and get its associated bare metal compute service.
[apiInstance startVMWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_startVM_body}} Input to start a VM.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_startVM_body(); // Simid_startVM_body | Input to start a VM.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Starts a VM and get its associated bare metal compute service.
                ServiceResponse result = apiInstance.startVM(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.startVM: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_startVM_body | Input to start a VM.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_startVM_body->new(); # Simid_startVM_body | Input to start a VM.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->startVM(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->startVM: $@\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.WRENCHApi()
body =  # Simid_startVM_body | Input to start a VM.
simid = simid_example # String | ID of the simulation

try: 
    # Starts a VM and get its associated bare metal compute service.
    api_response = api_instance.start_vm(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->startVM: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Job_name_submit_body body = ; // Job_name_submit_body | Job characteristics.
        String simid = simid_example; // String | ID of the simulation
        String jobName = jobName_example; // String | ID of the job
        try {
            GenericResponse result = apiInstance.submitStandardJob(body, simid, jobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#submitStandardJob");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Job_name_submit_body body = ; // Job_name_submit_body | Job characteristics.
        String simid = simid_example; // String | ID of the simulation
        String jobName = jobName_example; // String | ID of the job
        try {
            GenericResponse result = apiInstance.submitStandardJob(body, simid, jobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#submitStandardJob");
            e.printStackTrace();
        }
    }
}

Job_name_submit_body *body = ; // Job characteristics.
String *simid = simid_example; // ID of the simulation
String *jobName = jobName_example; // ID of the job

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

// Submit a standard job.
[apiInstance submitStandardJobWith:body
    simid:simid
    jobName:jobName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Job_name_submit_body}} Job characteristics.
var simid = simid_example; // {{String}} ID of the simulation
var jobName = jobName_example; // {{String}} ID of the job

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Job_name_submit_body(); // Job_name_submit_body | Job characteristics.
            var simid = simid_example;  // String | ID of the simulation
            var jobName = jobName_example;  // String | ID of the job

            try
            {
                // Submit a standard job.
                GenericResponse result = apiInstance.submitStandardJob(body, simid, jobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.submitStandardJob: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Job_name_submit_body | Job characteristics.
$simid = simid_example; // String | ID of the simulation
$jobName = jobName_example; // String | ID of the job

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Job_name_submit_body->new(); # Job_name_submit_body | Job characteristics.
my $simid = simid_example; # String | ID of the simulation
my $jobName = jobName_example; # String | ID of the job

eval { 
    my $result = $api_instance->submitStandardJob(body => $body, simid => $simid, jobName => $jobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->submitStandardJob: $@\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.WRENCHApi()
body =  # Job_name_submit_body | Job characteristics.
simid = simid_example # String | ID of the simulation
jobName = jobName_example # String | ID of the job

try: 
    # Submit a standard job.
    api_response = api_instance.submit_standard_job(body, simid, jobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->submitStandardJob: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            BooleanResponse result = apiInstance.supportsCompoundJobs(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#supportsCompoundJobs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            BooleanResponse result = apiInstance.supportsCompoundJobs(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#supportsCompoundJobs");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation

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

// Returns true if the service supports compound jobs.
[apiInstance supportsCompoundJobsWith:simid
              completionHandler: ^(BooleanResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Returns true if the service supports compound jobs.
                BooleanResponse result = apiInstance.supportsCompoundJobs(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.supportsCompoundJobs: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->supportsCompoundJobs(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->supportsCompoundJobs: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation

try: 
    # Returns true if the service supports compound jobs.
    api_response = api_instance.supports_compound_jobs(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->supportsCompoundJobs: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            BooleanResponse result = apiInstance.supportsPilotJobs(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#supportsPilotJobs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            BooleanResponse result = apiInstance.supportsPilotJobs(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#supportsPilotJobs");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation

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

// Returns true if the service supports pilot jobs.
[apiInstance supportsPilotJobsWith:simid
              completionHandler: ^(BooleanResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Returns true if the service supports pilot jobs.
                BooleanResponse result = apiInstance.supportsPilotJobs(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.supportsPilotJobs: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->supportsPilotJobs(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->supportsPilotJobs: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation

try: 
    # Returns true if the service supports pilot jobs.
    api_response = api_instance.supports_pilot_jobs(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->supportsPilotJobs: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            BooleanResponse result = apiInstance.supportsStandardJobs(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#supportsStandardJobs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            BooleanResponse result = apiInstance.supportsStandardJobs(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#supportsStandardJobs");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation

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

// Returns true if the service supports standard jobs.
[apiInstance supportsStandardJobsWith:simid
              completionHandler: ^(BooleanResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Returns true if the service supports standard jobs.
                BooleanResponse result = apiInstance.supportsStandardJobs(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.supportsStandardJobs: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->supportsStandardJobs(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->supportsStandardJobs: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation

try: 
    # Returns true if the service supports standard jobs.
    api_response = api_instance.supports_standard_jobs(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->supportsStandardJobs: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_suspendVM_body body = ; // Simid_suspendVM_body | Input to suspend a VM.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.suspendVM(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#suspendVM");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_suspendVM_body body = ; // Simid_suspendVM_body | Input to suspend a VM.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.suspendVM(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#suspendVM");
            e.printStackTrace();
        }
    }
}

Simid_suspendVM_body *body = ; // Input to suspend a VM.
String *simid = simid_example; // ID of the simulation

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

// Suspends a running VM.
[apiInstance suspendVMWith:body
    simid:simid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_suspendVM_body}} Input to suspend a VM.
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var body = new Simid_suspendVM_body(); // Simid_suspendVM_body | Input to suspend a VM.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Suspends a running VM.
                GenericResponse result = apiInstance.suspendVM(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.suspendVM: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_suspendVM_body | Input to suspend a VM.
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_suspendVM_body->new(); # Simid_suspendVM_body | Input to suspend a VM.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->suspendVM(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->suspendVM: $@\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.WRENCHApi()
body =  # Simid_suspendVM_body | Input to suspend a VM.
simid = simid_example # String | ID of the simulation

try: 
    # Suspends a running VM.
    api_response = api_instance.suspend_vm(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->suspendVM: %s\n" % e)

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

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

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            Event result = apiInstance.waitForNextSimulationEvent(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#waitForNextSimulationEvent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            Event result = apiInstance.waitForNextSimulationEvent(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#waitForNextSimulationEvent");
            e.printStackTrace();
        }
    }
}

String *simid = simid_example; // ID of the simulation

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

// Retrieve the next simulation event.
[apiInstance waitForNextSimulationEventWith:simid
              completionHandler: ^(Event output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation

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

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

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

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Retrieve the next simulation event.
                Event result = apiInstance.waitForNextSimulationEvent(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.waitForNextSimulationEvent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation

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

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

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->waitForNextSimulationEvent(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->waitForNextSimulationEvent: $@\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.WRENCHApi()
simid = simid_example # String | ID of the simulation

try: 
    # Retrieve the next simulation event.
    api_response = api_instance.wait_for_next_simulation_event(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->waitForNextSimulationEvent: %s\n" % e)