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

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

public class DevApiExample {

    public static void main(String[] args) {

        DevApi apiInstance = new DevApi();
        try {
            apiInstance.versionUsingGET();
        } catch (ApiException e) {
            System.err.println("Exception when calling DevApi#versionUsingGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DevApi;

public class DevApiExample {

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

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

// check instance's version
[apiInstance versionUsingGETWithCompletionHandler:
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.DevApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.versionUsingGET(callback);

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

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

            var apiInstance = new DevApi();

            try
            {
                // check instance's version
                apiInstance.versionUsingGET();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DevApi.versionUsingGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DevApi();

try {
    $api_instance->versionUsingGET();
} catch (Exception $e) {
    echo 'Exception when calling DevApi->versionUsingGET: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->versionUsingGET();
};
if ($@) {
    warn "Exception when calling DevApi->versionUsingGET: $@\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.DevApi()

try:
    # check instance's version
    api_instance.version_using_get()
except ApiException as e:
    print("Exception when calling DevApi->versionUsingGET: %s\n" % e)

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

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

public class FunctionApiExample {

    public static void main(String[] args) {

        FunctionApi apiInstance = new FunctionApi();
        array[Integer] ids = ; // array[Integer] |
        try {
            HyperonApiGetFunctionResponse result = apiInstance.getFunctionUsingGET(ids);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FunctionApi#getFunctionUsingGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FunctionApi;

public class FunctionApiExample {

    public static void main(String[] args) {
        FunctionApi apiInstance = new FunctionApi();
        array[Integer] ids = ; // array[Integer] |
        try {
            HyperonApiGetFunctionResponse result = apiInstance.getFunctionUsingGET(ids);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FunctionApi#getFunctionUsingGET");
            e.printStackTrace();
        }
    }
}

array[Integer] *ids = ; //  (optional)

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

// Gets function details
[apiInstance getFunctionUsingGETWith:ids
              completionHandler: ^(HyperonApiGetFunctionResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.FunctionApi()

var opts = {
  'ids':  // {array[Integer]}
};

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

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

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

            var apiInstance = new FunctionApi();
            var ids = new array[Integer](); // array[Integer] |  (optional)

            try
            {
                // Gets function details
                HyperonApiGetFunctionResponse result = apiInstance.getFunctionUsingGET(ids);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FunctionApi.getFunctionUsingGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\FunctionApi();
$ids = ; // array[Integer] |

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

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

my $api_instance = WWW::SwaggerClient::FunctionApi->new();
my $ids = []; # array[Integer] |

eval {
    my $result = $api_instance->getFunctionUsingGET(ids => $ids);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FunctionApi->getFunctionUsingGET: $@\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.FunctionApi()
ids =  # array[Integer] |  (optional)

try:
    # Gets function details
    api_response = api_instance.get_function_using_get(ids=ids)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FunctionApi->getFunctionUsingGET: %s\n" % e)

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

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

public class LocalWorkSessionApiExample {

    public static void main(String[] args) {

        LocalWorkSessionApi apiInstance = new LocalWorkSessionApi();
        try {
            HyperonApiGetOrCreateSessionResponse result = apiInstance.getOrCreateUsingPOST();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LocalWorkSessionApi#getOrCreateUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LocalWorkSessionApi;

public class LocalWorkSessionApiExample {

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

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

// Creates work session or returns existing
[apiInstance getOrCreateUsingPOSTWithCompletionHandler:
              ^(HyperonApiGetOrCreateSessionResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.LocalWorkSessionApi()

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

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

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

            var apiInstance = new LocalWorkSessionApi();

            try
            {
                // Creates work session or returns existing
                HyperonApiGetOrCreateSessionResponse result = apiInstance.getOrCreateUsingPOST();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LocalWorkSessionApi.getOrCreateUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\LocalWorkSessionApi();

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

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

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

eval {
    my $result = $api_instance->getOrCreateUsingPOST();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LocalWorkSessionApi->getOrCreateUsingPOST: $@\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.LocalWorkSessionApi()

try:
    # Creates work session or returns existing
    api_response = api_instance.get_or_create_using_post()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LocalWorkSessionApi->getOrCreateUsingPOST: %s\n" % e)

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

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

public class MetadataApiExample {

    public static void main(String[] args) {

        MetadataApi apiInstance = new MetadataApi();
        try {
            HyperonApiGetMetadataResponse result = apiInstance.allUsingGET();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetadataApi#allUsingGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MetadataApi;

public class MetadataApiExample {

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

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

// Get all metadata
[apiInstance allUsingGETWithCompletionHandler:
              ^(HyperonApiGetMetadataResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.MetadataApi()

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

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

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

            var apiInstance = new MetadataApi();

            try
            {
                // Get all metadata
                HyperonApiGetMetadataResponse result = apiInstance.allUsingGET();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MetadataApi.allUsingGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MetadataApi();

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

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

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

eval {
    my $result = $api_instance->allUsingGET();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MetadataApi->allUsingGET: $@\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.MetadataApi()

try:
    # Get all metadata
    api_response = api_instance.all_using_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MetadataApi->allUsingGET: %s\n" % e)

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

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

public class MetadataApiExample {

    public static void main(String[] args) {

        MetadataApi apiInstance = new MetadataApi();
        try {
            HyperonApiGetFunctionsResponse result = apiInstance.functionsUsingGET();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetadataApi#functionsUsingGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MetadataApi;

public class MetadataApiExample {

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

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

// Get all function's metadata
[apiInstance functionsUsingGETWithCompletionHandler:
              ^(HyperonApiGetFunctionsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.MetadataApi()

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

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

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

            var apiInstance = new MetadataApi();

            try
            {
                // Get all function's metadata
                HyperonApiGetFunctionsResponse result = apiInstance.functionsUsingGET();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MetadataApi.functionsUsingGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MetadataApi();

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

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

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

eval {
    my $result = $api_instance->functionsUsingGET();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MetadataApi->functionsUsingGET: $@\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.MetadataApi()

try:
    # Get all function's metadata
    api_response = api_instance.functions_using_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MetadataApi->functionsUsingGET: %s\n" % e)

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

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

public class MetadataApiExample {

    public static void main(String[] args) {

        MetadataApi apiInstance = new MetadataApi();
        try {
            HyperonApiGetProfilesResponse result = apiInstance.profilesUsingGET();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetadataApi#profilesUsingGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MetadataApi;

public class MetadataApiExample {

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

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

// Get all profile's name
[apiInstance profilesUsingGETWithCompletionHandler:
              ^(HyperonApiGetProfilesResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.MetadataApi()

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

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

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

            var apiInstance = new MetadataApi();

            try
            {
                // Get all profile's name
                HyperonApiGetProfilesResponse result = apiInstance.profilesUsingGET();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MetadataApi.profilesUsingGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MetadataApi();

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

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

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

eval {
    my $result = $api_instance->profilesUsingGET();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MetadataApi->profilesUsingGET: $@\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.MetadataApi()

try:
    # Get all profile's name
    api_response = api_instance.profiles_using_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MetadataApi->profilesUsingGET: %s\n" % e)

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

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

public class MetadataApiExample {

    public static void main(String[] args) {

        MetadataApi apiInstance = new MetadataApi();
        try {
            HyperonApiGetRegionsResponse result = apiInstance.regionsUsingGET();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetadataApi#regionsUsingGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MetadataApi;

public class MetadataApiExample {

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

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

// Get all region's metadata
[apiInstance regionsUsingGETWithCompletionHandler:
              ^(HyperonApiGetRegionsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.MetadataApi()

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

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

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

            var apiInstance = new MetadataApi();

            try
            {
                // Get all region's metadata
                HyperonApiGetRegionsResponse result = apiInstance.regionsUsingGET();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MetadataApi.regionsUsingGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MetadataApi();

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

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

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

eval {
    my $result = $api_instance->regionsUsingGET();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MetadataApi->regionsUsingGET: $@\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.MetadataApi()

try:
    # Get all region's metadata
    api_response = api_instance.regions_using_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MetadataApi->regionsUsingGET: %s\n" % e)

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

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

public class ParameterApiExample {

    public static void main(String[] args) {

        ParameterApi apiInstance = new ParameterApi();
        String paramCode = paramCode_example; // String | parameter's full code
        try {
            'Integer' result = apiInstance.addParameterToWorkSessionUsingGET(paramCode);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterApi#addParameterToWorkSessionUsingGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterApi;

public class ParameterApiExample {

    public static void main(String[] args) {
        ParameterApi apiInstance = new ParameterApi();
        String paramCode = paramCode_example; // String | parameter's full code
        try {
            'Integer' result = apiInstance.addParameterToWorkSessionUsingGET(paramCode);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterApi#addParameterToWorkSessionUsingGET");
            e.printStackTrace();
        }
    }
}

String *paramCode = paramCode_example; // parameter's full code

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

// Adds parameter to active work session and returns its id
[apiInstance addParameterToWorkSessionUsingGETWith:paramCode
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterApi()

var paramCode = paramCode_example; // {String} parameter's full code


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

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

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

            var apiInstance = new ParameterApi();
            var paramCode = paramCode_example;  // String | parameter's full code

            try
            {
                // Adds parameter to active work session and returns its id
                'Integer' result = apiInstance.addParameterToWorkSessionUsingGET(paramCode);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterApi.addParameterToWorkSessionUsingGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterApi();
$paramCode = paramCode_example; // String | parameter's full code

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

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

my $api_instance = WWW::SwaggerClient::ParameterApi->new();
my $paramCode = paramCode_example; # String | parameter's full code

eval {
    my $result = $api_instance->addParameterToWorkSessionUsingGET(paramCode => $paramCode);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterApi->addParameterToWorkSessionUsingGET: $@\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.ParameterApi()
paramCode = paramCode_example # String | parameter's full code

try:
    # Adds parameter to active work session and returns its id
    api_response = api_instance.add_parameter_to_work_session_using_get(paramCode)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterApi->addParameterToWorkSessionUsingGET: %s\n" % e)

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

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

public class ParameterApiExample {

    public static void main(String[] args) {

        ParameterApi apiInstance = new ParameterApi();
        Integer paramId = 56; // Integer | parameter's id
        HyperonParameterRowsData rowsData = ; // HyperonParameterRowsData | rows to add
        try {
            MpServiceResult result = apiInstance.addRowsUsingPOST(paramId, rowsData);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterApi#addRowsUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterApi;

public class ParameterApiExample {

    public static void main(String[] args) {
        ParameterApi apiInstance = new ParameterApi();
        Integer paramId = 56; // Integer | parameter's id
        HyperonParameterRowsData rowsData = ; // HyperonParameterRowsData | rows to add
        try {
            MpServiceResult result = apiInstance.addRowsUsingPOST(paramId, rowsData);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterApi#addRowsUsingPOST");
            e.printStackTrace();
        }
    }
}

Integer *paramId = 56; // parameter's id
HyperonParameterRowsData *rowsData = ; // rows to add

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

// adds given rows to parameter with given id
[apiInstance addRowsUsingPOSTWith:paramId
    rowsData:rowsData
              completionHandler: ^(MpServiceResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterApi()

var paramId = 56; // {Integer} parameter's id

var rowsData = ; // {HyperonParameterRowsData} rows to add


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

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

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

            var apiInstance = new ParameterApi();
            var paramId = 56;  // Integer | parameter's id
            var rowsData = new HyperonParameterRowsData(); // HyperonParameterRowsData | rows to add

            try
            {
                // adds given rows to parameter with given id
                MpServiceResult result = apiInstance.addRowsUsingPOST(paramId, rowsData);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterApi.addRowsUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterApi();
$paramId = 56; // Integer | parameter's id
$rowsData = ; // HyperonParameterRowsData | rows to add

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

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

my $api_instance = WWW::SwaggerClient::ParameterApi->new();
my $paramId = 56; # Integer | parameter's id
my $rowsData = WWW::SwaggerClient::Object::HyperonParameterRowsData->new(); # HyperonParameterRowsData | rows to add

eval {
    my $result = $api_instance->addRowsUsingPOST(paramId => $paramId, rowsData => $rowsData);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterApi->addRowsUsingPOST: $@\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.ParameterApi()
paramId = 56 # Integer | parameter's id
rowsData =  # HyperonParameterRowsData | rows to add

try:
    # adds given rows to parameter with given id
    api_response = api_instance.add_rows_using_post(paramId, rowsData)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterApi->addRowsUsingPOST: %s\n" % e)

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

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

public class ParameterApiExample {

    public static void main(String[] args) {

        ParameterApi apiInstance = new ParameterApi();
        HyperonParameterMetadataRequest request = ; // HyperonParameterMetadataRequest | parameter identifier
        try {
            HyperonParameterMetadataResponse result = apiInstance.getParameterMetadataUsingPOST(request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterApi#getParameterMetadataUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterApi;

public class ParameterApiExample {

    public static void main(String[] args) {
        ParameterApi apiInstance = new ParameterApi();
        HyperonParameterMetadataRequest request = ; // HyperonParameterMetadataRequest | parameter identifier
        try {
            HyperonParameterMetadataResponse result = apiInstance.getParameterMetadataUsingPOST(request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterApi#getParameterMetadataUsingPOST");
            e.printStackTrace();
        }
    }
}

HyperonParameterMetadataRequest *request = ; // parameter identifier

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

// Returns given parameter's metadata
[apiInstance getParameterMetadataUsingPOSTWith:request
              completionHandler: ^(HyperonParameterMetadataResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterApi()

var request = ; // {HyperonParameterMetadataRequest} parameter identifier


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

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

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

            var apiInstance = new ParameterApi();
            var request = new HyperonParameterMetadataRequest(); // HyperonParameterMetadataRequest | parameter identifier

            try
            {
                // Returns given parameter's metadata
                HyperonParameterMetadataResponse result = apiInstance.getParameterMetadataUsingPOST(request);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterApi.getParameterMetadataUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterApi();
$request = ; // HyperonParameterMetadataRequest | parameter identifier

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

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

my $api_instance = WWW::SwaggerClient::ParameterApi->new();
my $request = WWW::SwaggerClient::Object::HyperonParameterMetadataRequest->new(); # HyperonParameterMetadataRequest | parameter identifier

eval {
    my $result = $api_instance->getParameterMetadataUsingPOST(request => $request);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterApi->getParameterMetadataUsingPOST: $@\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.ParameterApi()
request =  # HyperonParameterMetadataRequest | parameter identifier

try:
    # Returns given parameter's metadata
    api_response = api_instance.get_parameter_metadata_using_post(request)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterApi->getParameterMetadataUsingPOST: %s\n" % e)

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

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

public class ParameterApiExample {

    public static void main(String[] args) {

        ParameterApi apiInstance = new ParameterApi();
        try {
            'Integer' result = apiInstance.getWorkSessionUsingGET();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterApi#getWorkSessionUsingGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterApi;

public class ParameterApiExample {

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

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

// returns active work session id
[apiInstance getWorkSessionUsingGETWithCompletionHandler:
              ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterApi()

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

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

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

            var apiInstance = new ParameterApi();

            try
            {
                // returns active work session id
                'Integer' result = apiInstance.getWorkSessionUsingGET();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterApi.getWorkSessionUsingGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterApi();

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

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

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

eval {
    my $result = $api_instance->getWorkSessionUsingGET();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterApi->getWorkSessionUsingGET: $@\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.ParameterApi()

try:
    # returns active work session id
    api_response = api_instance.get_work_session_using_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterApi->getWorkSessionUsingGET: %s\n" % e)

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

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

public class ParameterApiExample {

    public static void main(String[] args) {

        ParameterApi apiInstance = new ParameterApi();
        try {
            MpServiceResult result = apiInstance.publishWorkSessionUsingGET();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterApi#publishWorkSessionUsingGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterApi;

public class ParameterApiExample {

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

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

// publishes logged user's active work session
[apiInstance publishWorkSessionUsingGETWithCompletionHandler:
              ^(MpServiceResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterApi()

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

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

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

            var apiInstance = new ParameterApi();

            try
            {
                // publishes logged user's active work session
                MpServiceResult result = apiInstance.publishWorkSessionUsingGET();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterApi.publishWorkSessionUsingGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterApi();

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

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

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

eval {
    my $result = $api_instance->publishWorkSessionUsingGET();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterApi->publishWorkSessionUsingGET: $@\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.ParameterApi()

try:
    # publishes logged user's active work session
    api_response = api_instance.publish_work_session_using_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterApi->publishWorkSessionUsingGET: %s\n" % e)

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

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

public class ParameterApiExample {

    public static void main(String[] args) {

        ParameterApi apiInstance = new ParameterApi();
        try {
            MpServiceResult result = apiInstance.rejectWorkSessionUsingGET();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterApi#rejectWorkSessionUsingGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterApi;

public class ParameterApiExample {

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

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

// rejects logged user's active work session
[apiInstance rejectWorkSessionUsingGETWithCompletionHandler:
              ^(MpServiceResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterApi()

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

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

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

            var apiInstance = new ParameterApi();

            try
            {
                // rejects logged user's active work session
                MpServiceResult result = apiInstance.rejectWorkSessionUsingGET();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterApi.rejectWorkSessionUsingGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterApi();

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

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

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

eval {
    my $result = $api_instance->rejectWorkSessionUsingGET();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterApi->rejectWorkSessionUsingGET: $@\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.ParameterApi()

try:
    # rejects logged user's active work session
    api_response = api_instance.reject_work_session_using_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterApi->rejectWorkSessionUsingGET: %s\n" % e)

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

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

public class ParameterApiExample {

    public static void main(String[] args) {

        ParameterApi apiInstance = new ParameterApi();
        Integer paramId = 56; // Integer | parameter's id
        try {
            MpServiceResult result = apiInstance.truncateRowsUsingGET(paramId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterApi#truncateRowsUsingGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterApi;

public class ParameterApiExample {

    public static void main(String[] args) {
        ParameterApi apiInstance = new ParameterApi();
        Integer paramId = 56; // Integer | parameter's id
        try {
            MpServiceResult result = apiInstance.truncateRowsUsingGET(paramId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterApi#truncateRowsUsingGET");
            e.printStackTrace();
        }
    }
}

Integer *paramId = 56; // parameter's id

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

// truncates all rows from parameter with given id
[apiInstance truncateRowsUsingGETWith:paramId
              completionHandler: ^(MpServiceResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterApi()

var paramId = 56; // {Integer} parameter's id


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

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

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

            var apiInstance = new ParameterApi();
            var paramId = 56;  // Integer | parameter's id

            try
            {
                // truncates all rows from parameter with given id
                MpServiceResult result = apiInstance.truncateRowsUsingGET(paramId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterApi.truncateRowsUsingGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterApi();
$paramId = 56; // Integer | parameter's id

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

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

my $api_instance = WWW::SwaggerClient::ParameterApi->new();
my $paramId = 56; # Integer | parameter's id

eval {
    my $result = $api_instance->truncateRowsUsingGET(paramId => $paramId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterApi->truncateRowsUsingGET: $@\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.ParameterApi()
paramId = 56 # Integer | parameter's id

try:
    # truncates all rows from parameter with given id
    api_response = api_instance.truncate_rows_using_get(paramId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterApi->truncateRowsUsingGET: %s\n" % e)

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

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

public class ParameterEntryApiExample {

    public static void main(String[] args) {

        ParameterEntryApi apiInstance = new ParameterEntryApi();
        HyperonParameterEntryAppendRequest appendRequest = ; // HyperonParameterEntryAppendRequest | appendRequest
        try {
            HyperonParameterEntryApiResult result = apiInstance.appendUsingPOST(appendRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterEntryApi#appendUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterEntryApi;

public class ParameterEntryApiExample {

    public static void main(String[] args) {
        ParameterEntryApi apiInstance = new ParameterEntryApi();
        HyperonParameterEntryAppendRequest appendRequest = ; // HyperonParameterEntryAppendRequest | appendRequest
        try {
            HyperonParameterEntryApiResult result = apiInstance.appendUsingPOST(appendRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterEntryApi#appendUsingPOST");
            e.printStackTrace();
        }
    }
}

HyperonParameterEntryAppendRequest *appendRequest = ; // appendRequest

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

// Adds given values to matrix
[apiInstance appendUsingPOSTWith:appendRequest
              completionHandler: ^(HyperonParameterEntryApiResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterEntryApi()

var appendRequest = ; // {HyperonParameterEntryAppendRequest} appendRequest


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

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

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

            var apiInstance = new ParameterEntryApi();
            var appendRequest = new HyperonParameterEntryAppendRequest(); // HyperonParameterEntryAppendRequest | appendRequest

            try
            {
                // Adds given values to matrix
                HyperonParameterEntryApiResult result = apiInstance.appendUsingPOST(appendRequest);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterEntryApi.appendUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterEntryApi();
$appendRequest = ; // HyperonParameterEntryAppendRequest | appendRequest

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

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

my $api_instance = WWW::SwaggerClient::ParameterEntryApi->new();
my $appendRequest = WWW::SwaggerClient::Object::HyperonParameterEntryAppendRequest->new(); # HyperonParameterEntryAppendRequest | appendRequest

eval {
    my $result = $api_instance->appendUsingPOST(appendRequest => $appendRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterEntryApi->appendUsingPOST: $@\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.ParameterEntryApi()
appendRequest =  # HyperonParameterEntryAppendRequest | appendRequest

try:
    # Adds given values to matrix
    api_response = api_instance.append_using_post(appendRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterEntryApi->appendUsingPOST: %s\n" % e)

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

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

public class ParameterEntryApiExample {

    public static void main(String[] args) {

        ParameterEntryApi apiInstance = new ParameterEntryApi();
        HyperonParameterEntryDeleteRequest deleteRequest = ; // HyperonParameterEntryDeleteRequest | deleteRequest
        try {
            HyperonParameterEntryApiResult result = apiInstance.deleteUsingPOST(deleteRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterEntryApi#deleteUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterEntryApi;

public class ParameterEntryApiExample {

    public static void main(String[] args) {
        ParameterEntryApi apiInstance = new ParameterEntryApi();
        HyperonParameterEntryDeleteRequest deleteRequest = ; // HyperonParameterEntryDeleteRequest | deleteRequest
        try {
            HyperonParameterEntryApiResult result = apiInstance.deleteUsingPOST(deleteRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterEntryApi#deleteUsingPOST");
            e.printStackTrace();
        }
    }
}

HyperonParameterEntryDeleteRequest *deleteRequest = ; // deleteRequest

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

// Finds entries in parameter matrix beginning with key values and removes them
[apiInstance deleteUsingPOSTWith:deleteRequest
              completionHandler: ^(HyperonParameterEntryApiResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterEntryApi()

var deleteRequest = ; // {HyperonParameterEntryDeleteRequest} deleteRequest


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

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

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

            var apiInstance = new ParameterEntryApi();
            var deleteRequest = new HyperonParameterEntryDeleteRequest(); // HyperonParameterEntryDeleteRequest | deleteRequest

            try
            {
                // Finds entries in parameter matrix beginning with key values and removes them
                HyperonParameterEntryApiResult result = apiInstance.deleteUsingPOST(deleteRequest);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterEntryApi.deleteUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterEntryApi();
$deleteRequest = ; // HyperonParameterEntryDeleteRequest | deleteRequest

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

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

my $api_instance = WWW::SwaggerClient::ParameterEntryApi->new();
my $deleteRequest = WWW::SwaggerClient::Object::HyperonParameterEntryDeleteRequest->new(); # HyperonParameterEntryDeleteRequest | deleteRequest

eval {
    my $result = $api_instance->deleteUsingPOST(deleteRequest => $deleteRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterEntryApi->deleteUsingPOST: $@\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.ParameterEntryApi()
deleteRequest =  # HyperonParameterEntryDeleteRequest | deleteRequest

try:
    # Finds entries in parameter matrix beginning with key values and removes them
    api_response = api_instance.delete_using_post(deleteRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterEntryApi->deleteUsingPOST: %s\n" % e)

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

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

public class ParameterEntryApiExample {

    public static void main(String[] args) {

        ParameterEntryApi apiInstance = new ParameterEntryApi();
        HyperonParameterEntrySearchRequest searchRequest = ; // HyperonParameterEntrySearchRequest | searchRequest
        try {
            HyperonParameterEntrySearchResult result = apiInstance.findUsingPOST(searchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterEntryApi#findUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterEntryApi;

public class ParameterEntryApiExample {

    public static void main(String[] args) {
        ParameterEntryApi apiInstance = new ParameterEntryApi();
        HyperonParameterEntrySearchRequest searchRequest = ; // HyperonParameterEntrySearchRequest | searchRequest
        try {
            HyperonParameterEntrySearchResult result = apiInstance.findUsingPOST(searchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterEntryApi#findUsingPOST");
            e.printStackTrace();
        }
    }
}

HyperonParameterEntrySearchRequest *searchRequest = ; // searchRequest

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

// Finds entries in parameter matrix
[apiInstance findUsingPOSTWith:searchRequest
              completionHandler: ^(HyperonParameterEntrySearchResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterEntryApi()

var searchRequest = ; // {HyperonParameterEntrySearchRequest} searchRequest


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

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

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

            var apiInstance = new ParameterEntryApi();
            var searchRequest = new HyperonParameterEntrySearchRequest(); // HyperonParameterEntrySearchRequest | searchRequest

            try
            {
                // Finds entries in parameter matrix
                HyperonParameterEntrySearchResult result = apiInstance.findUsingPOST(searchRequest);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterEntryApi.findUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterEntryApi();
$searchRequest = ; // HyperonParameterEntrySearchRequest | searchRequest

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

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

my $api_instance = WWW::SwaggerClient::ParameterEntryApi->new();
my $searchRequest = WWW::SwaggerClient::Object::HyperonParameterEntrySearchRequest->new(); # HyperonParameterEntrySearchRequest | searchRequest

eval {
    my $result = $api_instance->findUsingPOST(searchRequest => $searchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterEntryApi->findUsingPOST: $@\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.ParameterEntryApi()
searchRequest =  # HyperonParameterEntrySearchRequest | searchRequest

try:
    # Finds entries in parameter matrix
    api_response = api_instance.find_using_post(searchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterEntryApi->findUsingPOST: %s\n" % e)

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

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

public class ParameterEntryApiExample {

    public static void main(String[] args) {

        ParameterEntryApi apiInstance = new ParameterEntryApi();
        HyperonParameterEntryInsertRequest insertRequest = ; // HyperonParameterEntryInsertRequest | insertRequest
        try {
            HyperonParameterEntryApiResult result = apiInstance.insertUsingPOST(insertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterEntryApi#insertUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterEntryApi;

public class ParameterEntryApiExample {

    public static void main(String[] args) {
        ParameterEntryApi apiInstance = new ParameterEntryApi();
        HyperonParameterEntryInsertRequest insertRequest = ; // HyperonParameterEntryInsertRequest | insertRequest
        try {
            HyperonParameterEntryApiResult result = apiInstance.insertUsingPOST(insertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterEntryApi#insertUsingPOST");
            e.printStackTrace();
        }
    }
}

HyperonParameterEntryInsertRequest *insertRequest = ; // insertRequest

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

// Adds given values to matrix
[apiInstance insertUsingPOSTWith:insertRequest
              completionHandler: ^(HyperonParameterEntryApiResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterEntryApi()

var insertRequest = ; // {HyperonParameterEntryInsertRequest} insertRequest


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

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

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

            var apiInstance = new ParameterEntryApi();
            var insertRequest = new HyperonParameterEntryInsertRequest(); // HyperonParameterEntryInsertRequest | insertRequest

            try
            {
                // Adds given values to matrix
                HyperonParameterEntryApiResult result = apiInstance.insertUsingPOST(insertRequest);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterEntryApi.insertUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterEntryApi();
$insertRequest = ; // HyperonParameterEntryInsertRequest | insertRequest

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

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

my $api_instance = WWW::SwaggerClient::ParameterEntryApi->new();
my $insertRequest = WWW::SwaggerClient::Object::HyperonParameterEntryInsertRequest->new(); # HyperonParameterEntryInsertRequest | insertRequest

eval {
    my $result = $api_instance->insertUsingPOST(insertRequest => $insertRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterEntryApi->insertUsingPOST: $@\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.ParameterEntryApi()
insertRequest =  # HyperonParameterEntryInsertRequest | insertRequest

try:
    # Adds given values to matrix
    api_response = api_instance.insert_using_post(insertRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterEntryApi->insertUsingPOST: %s\n" % e)

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

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

public class ParameterEntryApiExample {

    public static void main(String[] args) {

        ParameterEntryApi apiInstance = new ParameterEntryApi();
        HyperonParameterEntryTruncateRequest truncateRequest = ; // HyperonParameterEntryTruncateRequest | truncateRequest
        try {
            HyperonParameterEntryApiResult result = apiInstance.truncateUsingPOST(truncateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterEntryApi#truncateUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterEntryApi;

public class ParameterEntryApiExample {

    public static void main(String[] args) {
        ParameterEntryApi apiInstance = new ParameterEntryApi();
        HyperonParameterEntryTruncateRequest truncateRequest = ; // HyperonParameterEntryTruncateRequest | truncateRequest
        try {
            HyperonParameterEntryApiResult result = apiInstance.truncateUsingPOST(truncateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterEntryApi#truncateUsingPOST");
            e.printStackTrace();
        }
    }
}

HyperonParameterEntryTruncateRequest *truncateRequest = ; // truncateRequest

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

// Removes all entries from given parameter
[apiInstance truncateUsingPOSTWith:truncateRequest
              completionHandler: ^(HyperonParameterEntryApiResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterEntryApi()

var truncateRequest = ; // {HyperonParameterEntryTruncateRequest} truncateRequest


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

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

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

            var apiInstance = new ParameterEntryApi();
            var truncateRequest = new HyperonParameterEntryTruncateRequest(); // HyperonParameterEntryTruncateRequest | truncateRequest

            try
            {
                // Removes all entries from given parameter
                HyperonParameterEntryApiResult result = apiInstance.truncateUsingPOST(truncateRequest);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterEntryApi.truncateUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterEntryApi();
$truncateRequest = ; // HyperonParameterEntryTruncateRequest | truncateRequest

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

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

my $api_instance = WWW::SwaggerClient::ParameterEntryApi->new();
my $truncateRequest = WWW::SwaggerClient::Object::HyperonParameterEntryTruncateRequest->new(); # HyperonParameterEntryTruncateRequest | truncateRequest

eval {
    my $result = $api_instance->truncateUsingPOST(truncateRequest => $truncateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterEntryApi->truncateUsingPOST: $@\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.ParameterEntryApi()
truncateRequest =  # HyperonParameterEntryTruncateRequest | truncateRequest

try:
    # Removes all entries from given parameter
    api_response = api_instance.truncate_using_post(truncateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterEntryApi->truncateUsingPOST: %s\n" % e)

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

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

public class ParameterEntryApiExample {

    public static void main(String[] args) {

        ParameterEntryApi apiInstance = new ParameterEntryApi();
        HyperonParameterEntryUpdateRequest updateRequest = ; // HyperonParameterEntryUpdateRequest | updateRequest
        try {
            HyperonParameterEntryApiResult result = apiInstance.updateUsingPUT(updateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterEntryApi#updateUsingPUT");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParameterEntryApi;

public class ParameterEntryApiExample {

    public static void main(String[] args) {
        ParameterEntryApi apiInstance = new ParameterEntryApi();
        HyperonParameterEntryUpdateRequest updateRequest = ; // HyperonParameterEntryUpdateRequest | updateRequest
        try {
            HyperonParameterEntryApiResult result = apiInstance.updateUsingPUT(updateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterEntryApi#updateUsingPUT");
            e.printStackTrace();
        }
    }
}

HyperonParameterEntryUpdateRequest *updateRequest = ; // updateRequest

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

// Finds entries in parameter matrix beginning with given key value and updates them with given values
[apiInstance updateUsingPUTWith:updateRequest
              completionHandler: ^(HyperonParameterEntryApiResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.ParameterEntryApi()

var updateRequest = ; // {HyperonParameterEntryUpdateRequest} updateRequest


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

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

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

            var apiInstance = new ParameterEntryApi();
            var updateRequest = new HyperonParameterEntryUpdateRequest(); // HyperonParameterEntryUpdateRequest | updateRequest

            try
            {
                // Finds entries in parameter matrix beginning with given key value and updates them with given values
                HyperonParameterEntryApiResult result = apiInstance.updateUsingPUT(updateRequest);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterEntryApi.updateUsingPUT: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ParameterEntryApi();
$updateRequest = ; // HyperonParameterEntryUpdateRequest | updateRequest

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

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

my $api_instance = WWW::SwaggerClient::ParameterEntryApi->new();
my $updateRequest = WWW::SwaggerClient::Object::HyperonParameterEntryUpdateRequest->new(); # HyperonParameterEntryUpdateRequest | updateRequest

eval {
    my $result = $api_instance->updateUsingPUT(updateRequest => $updateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterEntryApi->updateUsingPUT: $@\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.ParameterEntryApi()
updateRequest =  # HyperonParameterEntryUpdateRequest | updateRequest

try:
    # Finds entries in parameter matrix beginning with given key value and updates them with given values
    api_response = api_instance.update_using_put(updateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterEntryApi->updateUsingPUT: %s\n" % e)

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

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

public class RemoteOperationsApiExample {

    public static void main(String[] args) {

        RemoteOperationsApi apiInstance = new RemoteOperationsApi();
        HyperonParameterData rowsData = ; // HyperonParameterData | rowsData
        Integer sid = 56; // Integer | sid
        try {
            MpServiceResult result = apiInstance.addRowsUsingPOST1(rowsData, sid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteOperationsApi#addRowsUsingPOST1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RemoteOperationsApi;

public class RemoteOperationsApiExample {

    public static void main(String[] args) {
        RemoteOperationsApi apiInstance = new RemoteOperationsApi();
        HyperonParameterData rowsData = ; // HyperonParameterData | rowsData
        Integer sid = 56; // Integer | sid
        try {
            MpServiceResult result = apiInstance.addRowsUsingPOST1(rowsData, sid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteOperationsApi#addRowsUsingPOST1");
            e.printStackTrace();
        }
    }
}

HyperonParameterData *rowsData = ; // rowsData
Integer *sid = 56; // sid

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

// Adds given rows into given parameter
[apiInstance addRowsUsingPOST1With:rowsData
    sid:sid
              completionHandler: ^(MpServiceResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.RemoteOperationsApi()

var rowsData = ; // {HyperonParameterData} rowsData

var sid = 56; // {Integer} sid


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

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

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

            var apiInstance = new RemoteOperationsApi();
            var rowsData = new HyperonParameterData(); // HyperonParameterData | rowsData
            var sid = 56;  // Integer | sid

            try
            {
                // Adds given rows into given parameter
                MpServiceResult result = apiInstance.addRowsUsingPOST1(rowsData, sid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RemoteOperationsApi.addRowsUsingPOST1: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RemoteOperationsApi();
$rowsData = ; // HyperonParameterData | rowsData
$sid = 56; // Integer | sid

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

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

my $api_instance = WWW::SwaggerClient::RemoteOperationsApi->new();
my $rowsData = WWW::SwaggerClient::Object::HyperonParameterData->new(); # HyperonParameterData | rowsData
my $sid = 56; # Integer | sid

eval {
    my $result = $api_instance->addRowsUsingPOST1(rowsData => $rowsData, sid => $sid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RemoteOperationsApi->addRowsUsingPOST1: $@\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.RemoteOperationsApi()
rowsData =  # HyperonParameterData | rowsData
sid = 56 # Integer | sid

try:
    # Adds given rows into given parameter
    api_response = api_instance.add_rows_using_post1(rowsData, sid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RemoteOperationsApi->addRowsUsingPOST1: %s\n" % e)

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

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

public class RemoteOperationsApiExample {

    public static void main(String[] args) {

        RemoteOperationsApi apiInstance = new RemoteOperationsApi();
        Integer ttlSeconds = 56; // Integer | ttlSeconds
        try {
            'Integer' result = apiInstance.createWorkSessionUsingPOST(ttlSeconds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteOperationsApi#createWorkSessionUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RemoteOperationsApi;

public class RemoteOperationsApiExample {

    public static void main(String[] args) {
        RemoteOperationsApi apiInstance = new RemoteOperationsApi();
        Integer ttlSeconds = 56; // Integer | ttlSeconds
        try {
            'Integer' result = apiInstance.createWorkSessionUsingPOST(ttlSeconds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteOperationsApi#createWorkSessionUsingPOST");
            e.printStackTrace();
        }
    }
}

Integer *ttlSeconds = 56; // ttlSeconds

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

// Creates backend work session
[apiInstance createWorkSessionUsingPOSTWith:ttlSeconds
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.RemoteOperationsApi()

var ttlSeconds = 56; // {Integer} ttlSeconds


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

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

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

            var apiInstance = new RemoteOperationsApi();
            var ttlSeconds = 56;  // Integer | ttlSeconds

            try
            {
                // Creates backend work session
                'Integer' result = apiInstance.createWorkSessionUsingPOST(ttlSeconds);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RemoteOperationsApi.createWorkSessionUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RemoteOperationsApi();
$ttlSeconds = 56; // Integer | ttlSeconds

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

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

my $api_instance = WWW::SwaggerClient::RemoteOperationsApi->new();
my $ttlSeconds = WWW::SwaggerClient::Object::Integer->new(); # Integer | ttlSeconds

eval {
    my $result = $api_instance->createWorkSessionUsingPOST(ttlSeconds => $ttlSeconds);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RemoteOperationsApi->createWorkSessionUsingPOST: $@\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.RemoteOperationsApi()
ttlSeconds = 56 # Integer | ttlSeconds

try:
    # Creates backend work session
    api_response = api_instance.create_work_session_using_post(ttlSeconds)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RemoteOperationsApi->createWorkSessionUsingPOST: %s\n" % e)

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

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

public class RemoteOperationsApiExample {

    public static void main(String[] args) {

        RemoteOperationsApi apiInstance = new RemoteOperationsApi();
        Integer sid = 56; // Integer | sid
        SessionMessage msg = ; // SessionMessage | msg
        try {
            MpServiceResult result = apiInstance.publishWorkSessionUsingPOST(sid, msg);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteOperationsApi#publishWorkSessionUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RemoteOperationsApi;

public class RemoteOperationsApiExample {

    public static void main(String[] args) {
        RemoteOperationsApi apiInstance = new RemoteOperationsApi();
        Integer sid = 56; // Integer | sid
        SessionMessage msg = ; // SessionMessage | msg
        try {
            MpServiceResult result = apiInstance.publishWorkSessionUsingPOST(sid, msg);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteOperationsApi#publishWorkSessionUsingPOST");
            e.printStackTrace();
        }
    }
}

Integer *sid = 56; // sid
SessionMessage *msg = ; // msg (optional)

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

// Publishes given work session with optional message
[apiInstance publishWorkSessionUsingPOSTWith:sid
    msg:msg
              completionHandler: ^(MpServiceResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.RemoteOperationsApi()

var sid = 56; // {Integer} sid

var opts = {
  'msg':  // {SessionMessage} msg
};

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

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

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

            var apiInstance = new RemoteOperationsApi();
            var sid = 56;  // Integer | sid
            var msg = new SessionMessage(); // SessionMessage | msg (optional)

            try
            {
                // Publishes given work session with optional message
                MpServiceResult result = apiInstance.publishWorkSessionUsingPOST(sid, msg);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RemoteOperationsApi.publishWorkSessionUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RemoteOperationsApi();
$sid = 56; // Integer | sid
$msg = ; // SessionMessage | msg

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

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

my $api_instance = WWW::SwaggerClient::RemoteOperationsApi->new();
my $sid = 56; # Integer | sid
my $msg = WWW::SwaggerClient::Object::SessionMessage->new(); # SessionMessage | msg

eval {
    my $result = $api_instance->publishWorkSessionUsingPOST(sid => $sid, msg => $msg);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RemoteOperationsApi->publishWorkSessionUsingPOST: $@\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.RemoteOperationsApi()
sid = 56 # Integer | sid
msg =  # SessionMessage | msg (optional)

try:
    # Publishes given work session with optional message
    api_response = api_instance.publish_work_session_using_post(sid, msg=msg)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RemoteOperationsApi->publishWorkSessionUsingPOST: %s\n" % e)

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

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

public class RemoteOperationsApiExample {

    public static void main(String[] args) {

        RemoteOperationsApi apiInstance = new RemoteOperationsApi();
        Integer sid = 56; // Integer | sid
        SessionMessage msg = ; // SessionMessage | msg
        try {
            MpServiceResult result = apiInstance.rejectWorkSessionUsingPOST(sid, msg);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteOperationsApi#rejectWorkSessionUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RemoteOperationsApi;

public class RemoteOperationsApiExample {

    public static void main(String[] args) {
        RemoteOperationsApi apiInstance = new RemoteOperationsApi();
        Integer sid = 56; // Integer | sid
        SessionMessage msg = ; // SessionMessage | msg
        try {
            MpServiceResult result = apiInstance.rejectWorkSessionUsingPOST(sid, msg);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteOperationsApi#rejectWorkSessionUsingPOST");
            e.printStackTrace();
        }
    }
}

Integer *sid = 56; // sid
SessionMessage *msg = ; // msg (optional)

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

// Rejects given work session with optional message
[apiInstance rejectWorkSessionUsingPOSTWith:sid
    msg:msg
              completionHandler: ^(MpServiceResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.RemoteOperationsApi()

var sid = 56; // {Integer} sid

var opts = {
  'msg':  // {SessionMessage} msg
};

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

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

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

            var apiInstance = new RemoteOperationsApi();
            var sid = 56;  // Integer | sid
            var msg = new SessionMessage(); // SessionMessage | msg (optional)

            try
            {
                // Rejects given work session with optional message
                MpServiceResult result = apiInstance.rejectWorkSessionUsingPOST(sid, msg);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RemoteOperationsApi.rejectWorkSessionUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RemoteOperationsApi();
$sid = 56; // Integer | sid
$msg = ; // SessionMessage | msg

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

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

my $api_instance = WWW::SwaggerClient::RemoteOperationsApi->new();
my $sid = 56; # Integer | sid
my $msg = WWW::SwaggerClient::Object::SessionMessage->new(); # SessionMessage | msg

eval {
    my $result = $api_instance->rejectWorkSessionUsingPOST(sid => $sid, msg => $msg);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RemoteOperationsApi->rejectWorkSessionUsingPOST: $@\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.RemoteOperationsApi()
sid = 56 # Integer | sid
msg =  # SessionMessage | msg (optional)

try:
    # Rejects given work session with optional message
    api_response = api_instance.reject_work_session_using_post(sid, msg=msg)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RemoteOperationsApi->rejectWorkSessionUsingPOST: %s\n" % e)

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

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

public class RemoteOperationsApiExample {

    public static void main(String[] args) {

        RemoteOperationsApi apiInstance = new RemoteOperationsApi();
        HyperonElementIdentifier param = ; // HyperonElementIdentifier | param
        Integer sid = 56; // Integer | sid
        try {
            MpServiceResult result = apiInstance.truncateRowsUsingPOST(param, sid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteOperationsApi#truncateRowsUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RemoteOperationsApi;

public class RemoteOperationsApiExample {

    public static void main(String[] args) {
        RemoteOperationsApi apiInstance = new RemoteOperationsApi();
        HyperonElementIdentifier param = ; // HyperonElementIdentifier | param
        Integer sid = 56; // Integer | sid
        try {
            MpServiceResult result = apiInstance.truncateRowsUsingPOST(param, sid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteOperationsApi#truncateRowsUsingPOST");
            e.printStackTrace();
        }
    }
}

HyperonElementIdentifier *param = ; // param
Integer *sid = 56; // sid

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

// Truncates all rows in given parameter
[apiInstance truncateRowsUsingPOSTWith:param
    sid:sid
              completionHandler: ^(MpServiceResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.RemoteOperationsApi()

var param = ; // {HyperonElementIdentifier} param

var sid = 56; // {Integer} sid


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

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

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

            var apiInstance = new RemoteOperationsApi();
            var param = new HyperonElementIdentifier(); // HyperonElementIdentifier | param
            var sid = 56;  // Integer | sid

            try
            {
                // Truncates all rows in given parameter
                MpServiceResult result = apiInstance.truncateRowsUsingPOST(param, sid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RemoteOperationsApi.truncateRowsUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RemoteOperationsApi();
$param = ; // HyperonElementIdentifier | param
$sid = 56; // Integer | sid

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

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

my $api_instance = WWW::SwaggerClient::RemoteOperationsApi->new();
my $param = WWW::SwaggerClient::Object::HyperonElementIdentifier->new(); # HyperonElementIdentifier | param
my $sid = 56; # Integer | sid

eval {
    my $result = $api_instance->truncateRowsUsingPOST(param => $param, sid => $sid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RemoteOperationsApi->truncateRowsUsingPOST: $@\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.RemoteOperationsApi()
param =  # HyperonElementIdentifier | param
sid = 56 # Integer | sid

try:
    # Truncates all rows in given parameter
    api_response = api_instance.truncate_rows_using_post(param, sid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RemoteOperationsApi->truncateRowsUsingPOST: %s\n" % e)

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

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

public class RemoteWorkSessionApiExample {

    public static void main(String[] args) {

        RemoteWorkSessionApi apiInstance = new RemoteWorkSessionApi();
        Integer ttlSeconds = 56; // Integer | session's time to live in seconds
        try {
            'Integer' result = apiInstance.createUsingPOST(ttlSeconds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteWorkSessionApi#createUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RemoteWorkSessionApi;

public class RemoteWorkSessionApiExample {

    public static void main(String[] args) {
        RemoteWorkSessionApi apiInstance = new RemoteWorkSessionApi();
        Integer ttlSeconds = 56; // Integer | session's time to live in seconds
        try {
            'Integer' result = apiInstance.createUsingPOST(ttlSeconds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteWorkSessionApi#createUsingPOST");
            e.printStackTrace();
        }
    }
}

Integer *ttlSeconds = 56; // session's time to live in seconds

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

// returns id of newly created remote work session
[apiInstance createUsingPOSTWith:ttlSeconds
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.RemoteWorkSessionApi()

var ttlSeconds = 56; // {Integer} session's time to live in seconds


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

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

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

            var apiInstance = new RemoteWorkSessionApi();
            var ttlSeconds = 56;  // Integer | session's time to live in seconds

            try
            {
                // returns id of newly created remote work session
                'Integer' result = apiInstance.createUsingPOST(ttlSeconds);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RemoteWorkSessionApi.createUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RemoteWorkSessionApi();
$ttlSeconds = 56; // Integer | session's time to live in seconds

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

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

my $api_instance = WWW::SwaggerClient::RemoteWorkSessionApi->new();
my $ttlSeconds = 56; # Integer | session's time to live in seconds

eval {
    my $result = $api_instance->createUsingPOST(ttlSeconds => $ttlSeconds);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RemoteWorkSessionApi->createUsingPOST: $@\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.RemoteWorkSessionApi()
ttlSeconds = 56 # Integer | session's time to live in seconds

try:
    # returns id of newly created remote work session
    api_response = api_instance.create_using_post(ttlSeconds)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RemoteWorkSessionApi->createUsingPOST: %s\n" % e)

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

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

public class RemoteWorkSessionApiExample {

    public static void main(String[] args) {

        RemoteWorkSessionApi apiInstance = new RemoteWorkSessionApi();
        Integer sid = 56; // Integer | session's id
        try {
            Object result = apiInstance.getSessionDetailsUsingGET(sid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteWorkSessionApi#getSessionDetailsUsingGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RemoteWorkSessionApi;

public class RemoteWorkSessionApiExample {

    public static void main(String[] args) {
        RemoteWorkSessionApi apiInstance = new RemoteWorkSessionApi();
        Integer sid = 56; // Integer | session's id
        try {
            Object result = apiInstance.getSessionDetailsUsingGET(sid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RemoteWorkSessionApi#getSessionDetailsUsingGET");
            e.printStackTrace();
        }
    }
}

Integer *sid = 56; // session's id

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

// Returns remote session details
[apiInstance getSessionDetailsUsingGETWith:sid
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.RemoteWorkSessionApi()

var sid = 56; // {Integer} session's id


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

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

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

            var apiInstance = new RemoteWorkSessionApi();
            var sid = 56;  // Integer | session's id

            try
            {
                // Returns remote session details
                Object result = apiInstance.getSessionDetailsUsingGET(sid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RemoteWorkSessionApi.getSessionDetailsUsingGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RemoteWorkSessionApi();
$sid = 56; // Integer | session's id

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

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

my $api_instance = WWW::SwaggerClient::RemoteWorkSessionApi->new();
my $sid = 56; # Integer | session's id

eval {
    my $result = $api_instance->getSessionDetailsUsingGET(sid => $sid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RemoteWorkSessionApi->getSessionDetailsUsingGET: $@\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.RemoteWorkSessionApi()
sid = 56 # Integer | session's id

try:
    # Returns remote session details
    api_response = api_instance.get_session_details_using_get(sid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RemoteWorkSessionApi->getSessionDetailsUsingGET: %s\n" % e)

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

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

public class SnapshotApiExample {

    public static void main(String[] args) {

        SnapshotApi apiInstance = new SnapshotApi();
        SnapshotExportConfigRequestDto requestConfig = ; // SnapshotExportConfigRequestDto | export configuration
        try {
            Resource result = apiInstance.exportSnapshotUsingPOST(requestConfig);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SnapshotApi#exportSnapshotUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SnapshotApi;

public class SnapshotApiExample {

    public static void main(String[] args) {
        SnapshotApi apiInstance = new SnapshotApi();
        SnapshotExportConfigRequestDto requestConfig = ; // SnapshotExportConfigRequestDto | export configuration
        try {
            Resource result = apiInstance.exportSnapshotUsingPOST(requestConfig);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SnapshotApi#exportSnapshotUsingPOST");
            e.printStackTrace();
        }
    }
}

SnapshotExportConfigRequestDto *requestConfig = ; // export configuration (optional)

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

// Exports requested objects to snapshot zip file
[apiInstance exportSnapshotUsingPOSTWith:requestConfig
              completionHandler: ^(Resource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.SnapshotApi()

var opts = {
  'requestConfig':  // {SnapshotExportConfigRequestDto} export configuration
};

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

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

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

            var apiInstance = new SnapshotApi();
            var requestConfig = new SnapshotExportConfigRequestDto(); // SnapshotExportConfigRequestDto | export configuration (optional)

            try
            {
                // Exports requested objects to snapshot zip file
                Resource result = apiInstance.exportSnapshotUsingPOST(requestConfig);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SnapshotApi.exportSnapshotUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\SnapshotApi();
$requestConfig = ; // SnapshotExportConfigRequestDto | export configuration

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

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

my $api_instance = WWW::SwaggerClient::SnapshotApi->new();
my $requestConfig = WWW::SwaggerClient::Object::SnapshotExportConfigRequestDto->new(); # SnapshotExportConfigRequestDto | export configuration

eval {
    my $result = $api_instance->exportSnapshotUsingPOST(requestConfig => $requestConfig);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SnapshotApi->exportSnapshotUsingPOST: $@\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.SnapshotApi()
requestConfig =  # SnapshotExportConfigRequestDto | export configuration (optional)

try:
    # Exports requested objects to snapshot zip file
    api_response = api_instance.export_snapshot_using_post(requestConfig=requestConfig)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SnapshotApi->exportSnapshotUsingPOST: %s\n" % e)

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

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

public class SnapshotApiExample {

    public static void main(String[] args) {

        SnapshotApi apiInstance = new SnapshotApi();
        File file = /path/to/file.txt; // File | snapshot zip file
        Boolean autocommit = true; // Boolean | flag that controls session publication after import
        Boolean considerConfigFile = true; // Boolean | considerConfigFile
        try {
            SnapshotImportResultDto result = apiInstance.importSnapshotUsingPOST(file, autocommit, considerConfigFile);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SnapshotApi#importSnapshotUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SnapshotApi;

public class SnapshotApiExample {

    public static void main(String[] args) {
        SnapshotApi apiInstance = new SnapshotApi();
        File file = /path/to/file.txt; // File | snapshot zip file
        Boolean autocommit = true; // Boolean | flag that controls session publication after import
        Boolean considerConfigFile = true; // Boolean | considerConfigFile
        try {
            SnapshotImportResultDto result = apiInstance.importSnapshotUsingPOST(file, autocommit, considerConfigFile);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SnapshotApi#importSnapshotUsingPOST");
            e.printStackTrace();
        }
    }
}

File *file = /path/to/file.txt; // snapshot zip file
Boolean *autocommit = true; // flag that controls session publication after import (optional)
Boolean *considerConfigFile = true; // considerConfigFile (optional)

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

// Imports snapshot zip file
[apiInstance importSnapshotUsingPOSTWith:file
    autocommit:autocommit
    considerConfigFile:considerConfigFile
              completionHandler: ^(SnapshotImportResultDto output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.SnapshotApi()

var file = /path/to/file.txt; // {File} snapshot zip file

var opts = {
  'autocommit': true, // {Boolean} flag that controls session publication after import
  'considerConfigFile': true // {Boolean} considerConfigFile
};

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

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

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

            var apiInstance = new SnapshotApi();
            var file = new File(); // File | snapshot zip file
            var autocommit = true;  // Boolean | flag that controls session publication after import (optional)
            var considerConfigFile = true;  // Boolean | considerConfigFile (optional)

            try
            {
                // Imports snapshot zip file
                SnapshotImportResultDto result = apiInstance.importSnapshotUsingPOST(file, autocommit, considerConfigFile);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SnapshotApi.importSnapshotUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\SnapshotApi();
$file = /path/to/file.txt; // File | snapshot zip file
$autocommit = true; // Boolean | flag that controls session publication after import
$considerConfigFile = true; // Boolean | considerConfigFile

try {
    $result = $api_instance->importSnapshotUsingPOST($file, $autocommit, $considerConfigFile);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SnapshotApi->importSnapshotUsingPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::SnapshotApi->new();
my $file = /path/to/file.txt; # File | snapshot zip file
my $autocommit = true; # Boolean | flag that controls session publication after import
my $considerConfigFile = true; # Boolean | considerConfigFile

eval {
    my $result = $api_instance->importSnapshotUsingPOST(file => $file, autocommit => $autocommit, considerConfigFile => $considerConfigFile);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SnapshotApi->importSnapshotUsingPOST: $@\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.SnapshotApi()
file = /path/to/file.txt # File | snapshot zip file
autocommit = true # Boolean | flag that controls session publication after import (optional)
considerConfigFile = true # Boolean | considerConfigFile (optional)

try:
    # Imports snapshot zip file
    api_response = api_instance.import_snapshot_using_post(file, autocommit=autocommit, considerConfigFile=considerConfigFile)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SnapshotApi->importSnapshotUsingPOST: %s\n" % e)

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

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

public class SuperpackApiExample {

    public static void main(String[] args) {

        SuperpackApi apiInstance = new SuperpackApi();
        File file = /path/to/file.txt; // File | superpack configuration file known as pack.xml, can be located in every superpack zip file or downloaded from Hyperon Studio
        try {
            Object result = apiInstance.downloadUsingPOST(file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuperpackApi#downloadUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SuperpackApi;

public class SuperpackApiExample {

    public static void main(String[] args) {
        SuperpackApi apiInstance = new SuperpackApi();
        File file = /path/to/file.txt; // File | superpack configuration file known as pack.xml, can be located in every superpack zip file or downloaded from Hyperon Studio
        try {
            Object result = apiInstance.downloadUsingPOST(file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuperpackApi#downloadUsingPOST");
            e.printStackTrace();
        }
    }
}

File *file = /path/to/file.txt; // superpack configuration file known as pack.xml, can be located in every superpack zip file or downloaded from Hyperon Studio

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

// Exports requested objects to superpack zip file
[apiInstance downloadUsingPOSTWith:file
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.SuperpackApi()

var file = /path/to/file.txt; // {File} superpack configuration file known as pack.xml, can be located in every superpack zip file or downloaded from Hyperon Studio


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

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

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

            var apiInstance = new SuperpackApi();
            var file = new File(); // File | superpack configuration file known as pack.xml, can be located in every superpack zip file or downloaded from Hyperon Studio

            try
            {
                // Exports requested objects to superpack zip file
                Object result = apiInstance.downloadUsingPOST(file);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SuperpackApi.downloadUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\SuperpackApi();
$file = /path/to/file.txt; // File | superpack configuration file known as pack.xml, can be located in every superpack zip file or downloaded from Hyperon Studio

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

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

my $api_instance = WWW::SwaggerClient::SuperpackApi->new();
my $file = /path/to/file.txt; # File | superpack configuration file known as pack.xml, can be located in every superpack zip file or downloaded from Hyperon Studio

eval {
    my $result = $api_instance->downloadUsingPOST(file => $file);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SuperpackApi->downloadUsingPOST: $@\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.SuperpackApi()
file = /path/to/file.txt # File | superpack configuration file known as pack.xml, can be located in every superpack zip file or downloaded from Hyperon Studio

try:
    # Exports requested objects to superpack zip file
    api_response = api_instance.download_using_post(file)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SuperpackApi->downloadUsingPOST: %s\n" % e)

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

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

public class SuperpackApiExample {

    public static void main(String[] args) {

        SuperpackApi apiInstance = new SuperpackApi();
        File file = /path/to/file.txt; // File | superpack zip file
        try {
            'String' result = apiInstance.uploadUsingPOST(file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuperpackApi#uploadUsingPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SuperpackApi;

public class SuperpackApiExample {

    public static void main(String[] args) {
        SuperpackApi apiInstance = new SuperpackApi();
        File file = /path/to/file.txt; // File | superpack zip file
        try {
            'String' result = apiInstance.uploadUsingPOST(file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuperpackApi#uploadUsingPOST");
            e.printStackTrace();
        }
    }
}

File *file = /path/to/file.txt; // superpack zip file

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

// Imports superpack zip file
[apiInstance uploadUsingPOSTWith:file
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.SuperpackApi()

var file = /path/to/file.txt; // {File} superpack zip file


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

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

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

            var apiInstance = new SuperpackApi();
            var file = new File(); // File | superpack zip file

            try
            {
                // Imports superpack zip file
                'String' result = apiInstance.uploadUsingPOST(file);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SuperpackApi.uploadUsingPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\SuperpackApi();
$file = /path/to/file.txt; // File | superpack zip file

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

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

my $api_instance = WWW::SwaggerClient::SuperpackApi->new();
my $file = /path/to/file.txt; # File | superpack zip file

eval {
    my $result = $api_instance->uploadUsingPOST(file => $file);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SuperpackApi->uploadUsingPOST: $@\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.SuperpackApi()
file = /path/to/file.txt # File | superpack zip file

try:
    # Imports superpack zip file
    api_response = api_instance.upload_using_post(file)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SuperpackApi->uploadUsingPOST: %s\n" % e)

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

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

public class WorkSessionApiExample {

    public static void main(String[] args) {

        WorkSessionApi apiInstance = new WorkSessionApi();
        Integer ttlSeconds = 56; // Integer | session's time to live in seconds
        try {
            'Integer' result = apiInstance.createWorkSessionUsingPOST1(ttlSeconds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WorkSessionApi#createWorkSessionUsingPOST1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WorkSessionApi;

public class WorkSessionApiExample {

    public static void main(String[] args) {
        WorkSessionApi apiInstance = new WorkSessionApi();
        Integer ttlSeconds = 56; // Integer | session's time to live in seconds
        try {
            'Integer' result = apiInstance.createWorkSessionUsingPOST1(ttlSeconds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WorkSessionApi#createWorkSessionUsingPOST1");
            e.printStackTrace();
        }
    }
}

Integer *ttlSeconds = 56; // session's time to live in seconds

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

// returns id of newly created remote work session
[apiInstance createWorkSessionUsingPOST1With:ttlSeconds
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.WorkSessionApi()

var ttlSeconds = 56; // {Integer} session's time to live in seconds


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

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

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

            var apiInstance = new WorkSessionApi();
            var ttlSeconds = 56;  // Integer | session's time to live in seconds

            try
            {
                // returns id of newly created remote work session
                'Integer' result = apiInstance.createWorkSessionUsingPOST1(ttlSeconds);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WorkSessionApi.createWorkSessionUsingPOST1: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\WorkSessionApi();
$ttlSeconds = 56; // Integer | session's time to live in seconds

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

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

my $api_instance = WWW::SwaggerClient::WorkSessionApi->new();
my $ttlSeconds = WWW::SwaggerClient::Object::Integer->new(); # Integer | session's time to live in seconds

eval {
    my $result = $api_instance->createWorkSessionUsingPOST1(ttlSeconds => $ttlSeconds);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WorkSessionApi->createWorkSessionUsingPOST1: $@\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.WorkSessionApi()
ttlSeconds = 56 # Integer | session's time to live in seconds

try:
    # returns id of newly created remote work session
    api_response = api_instance.create_work_session_using_post1(ttlSeconds)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WorkSessionApi->createWorkSessionUsingPOST1: %s\n" % e)

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

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

public class WorkSessionApiExample {

    public static void main(String[] args) {

        WorkSessionApi apiInstance = new WorkSessionApi();
        Integer sid = 56; // Integer | session's id
        SessionMessage msg = ; // SessionMessage | session's publish message
        try {
            MpServiceResult result = apiInstance.publishWorkSessionUsingPOST1(sid, msg);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WorkSessionApi#publishWorkSessionUsingPOST1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WorkSessionApi;

public class WorkSessionApiExample {

    public static void main(String[] args) {
        WorkSessionApi apiInstance = new WorkSessionApi();
        Integer sid = 56; // Integer | session's id
        SessionMessage msg = ; // SessionMessage | session's publish message
        try {
            MpServiceResult result = apiInstance.publishWorkSessionUsingPOST1(sid, msg);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WorkSessionApi#publishWorkSessionUsingPOST1");
            e.printStackTrace();
        }
    }
}

Integer *sid = 56; // session's id
SessionMessage *msg = ; // session's publish message (optional)

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

// Publishes work session with given id
[apiInstance publishWorkSessionUsingPOST1With:sid
    msg:msg
              completionHandler: ^(MpServiceResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.WorkSessionApi()

var sid = 56; // {Integer} session's id

var opts = {
  'msg':  // {SessionMessage} session's publish message
};

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

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

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

            var apiInstance = new WorkSessionApi();
            var sid = 56;  // Integer | session's id
            var msg = new SessionMessage(); // SessionMessage | session's publish message (optional)

            try
            {
                // Publishes work session with given id
                MpServiceResult result = apiInstance.publishWorkSessionUsingPOST1(sid, msg);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WorkSessionApi.publishWorkSessionUsingPOST1: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\WorkSessionApi();
$sid = 56; // Integer | session's id
$msg = ; // SessionMessage | session's publish message

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

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

my $api_instance = WWW::SwaggerClient::WorkSessionApi->new();
my $sid = 56; # Integer | session's id
my $msg = WWW::SwaggerClient::Object::SessionMessage->new(); # SessionMessage | session's publish message

eval {
    my $result = $api_instance->publishWorkSessionUsingPOST1(sid => $sid, msg => $msg);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WorkSessionApi->publishWorkSessionUsingPOST1: $@\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.WorkSessionApi()
sid = 56 # Integer | session's id
msg =  # SessionMessage | session's publish message (optional)

try:
    # Publishes work session with given id
    api_response = api_instance.publish_work_session_using_post1(sid, msg=msg)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WorkSessionApi->publishWorkSessionUsingPOST1: %s\n" % e)

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

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

public class WorkSessionApiExample {

    public static void main(String[] args) {

        WorkSessionApi apiInstance = new WorkSessionApi();
        Integer sid = 56; // Integer | session's id
        SessionMessage msg = ; // SessionMessage | session's reject message
        try {
            MpServiceResult result = apiInstance.rejectWorkSessionUsingPOST1(sid, msg);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WorkSessionApi#rejectWorkSessionUsingPOST1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.WorkSessionApi;

public class WorkSessionApiExample {

    public static void main(String[] args) {
        WorkSessionApi apiInstance = new WorkSessionApi();
        Integer sid = 56; // Integer | session's id
        SessionMessage msg = ; // SessionMessage | session's reject message
        try {
            MpServiceResult result = apiInstance.rejectWorkSessionUsingPOST1(sid, msg);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WorkSessionApi#rejectWorkSessionUsingPOST1");
            e.printStackTrace();
        }
    }
}

Integer *sid = 56; // session's id
SessionMessage *msg = ; // session's reject message (optional)

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

// Rejects work session with given id
[apiInstance rejectWorkSessionUsingPOST1With:sid
    msg:msg
              completionHandler: ^(MpServiceResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var HyperonRestApi = require('hyperon_rest_api');

var api = new HyperonRestApi.WorkSessionApi()

var sid = 56; // {Integer} session's id

var opts = {
  'msg':  // {SessionMessage} session's reject message
};

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

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

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

            var apiInstance = new WorkSessionApi();
            var sid = 56;  // Integer | session's id
            var msg = new SessionMessage(); // SessionMessage | session's reject message (optional)

            try
            {
                // Rejects work session with given id
                MpServiceResult result = apiInstance.rejectWorkSessionUsingPOST1(sid, msg);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WorkSessionApi.rejectWorkSessionUsingPOST1: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\WorkSessionApi();
$sid = 56; // Integer | session's id
$msg = ; // SessionMessage | session's reject message

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

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

my $api_instance = WWW::SwaggerClient::WorkSessionApi->new();
my $sid = 56; # Integer | session's id
my $msg = WWW::SwaggerClient::Object::SessionMessage->new(); # SessionMessage | session's reject message

eval {
    my $result = $api_instance->rejectWorkSessionUsingPOST1(sid => $sid, msg => $msg);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WorkSessionApi->rejectWorkSessionUsingPOST1: $@\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.WorkSessionApi()
sid = 56 # Integer | session's id
msg =  # SessionMessage | session's reject message (optional)

try:
    # Rejects work session with given id
    api_response = api_instance.reject_work_session_using_post1(sid, msg=msg)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WorkSessionApi->rejectWorkSessionUsingPOST1: %s\n" % e)