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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to update
        array[String] resources = ; // array[String] | resources to activate
        try {
            apiInstance.activateResources(authorization, sid, resources);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activateResources");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to update
        array[String] resources = ; // array[String] | resources to activate
        try {
            apiInstance.activateResources(authorization, sid, resources);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#activateResources");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *sid = sid_example; // site id to update
array[String] *resources = ; // resources to activate (optional)

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

// Activate a set of resources
[apiInstance activateResourcesWith:authorization
    sid:sid
    resources:resources
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var sid = sid_example; // {String} site id to update

var opts = { 
  'resources':  // {array[String]} resources to activate
};

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

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

namespace Example
{
    public class activateResourcesExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var sid = sid_example;  // String | site id to update
            var resources = new array[String](); // array[String] | resources to activate (optional) 

            try
            {
                // Activate a set of resources
                apiInstance.activateResources(authorization, sid, resources);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activateResources: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$sid = sid_example; // String | site id to update
$resources = ; // array[String] | resources to activate

try {
    $api_instance->activateResources($authorization, $sid, $resources);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->activateResources: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $sid = sid_example; # String | site id to update
my $resources = [WWW::SwaggerClient::Object::array[String]->new()]; # array[String] | resources to activate

eval { 
    $api_instance->activateResources(authorization => $authorization, sid => $sid, resources => $resources);
};
if ($@) {
    warn "Exception when calling DefaultApi->activateResources: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
sid = sid_example # String | site id to update
resources =  # array[String] | resources to activate (optional)

try: 
    # Activate a set of resources
    api_instance.activate_resources(authorization, sid, resources=resources)
except ApiException as e:
    print("Exception when calling DefaultApi->activateResources: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to add the member to
        String mid = mid_example; // String | project member id to add. Must be the same as the user id.
        ProjectMember newProjectMember = ; // ProjectMember | Project member details to add. State will be ignored and set to pending.
        try {
            apiInstance.addProjectMember(authorization, pid, mid, newProjectMember);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#addProjectMember");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to add the member to
        String mid = mid_example; // String | project member id to add. Must be the same as the user id.
        ProjectMember newProjectMember = ; // ProjectMember | Project member details to add. State will be ignored and set to pending.
        try {
            apiInstance.addProjectMember(authorization, pid, mid, newProjectMember);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#addProjectMember");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id to add the member to
String *mid = mid_example; // project member id to add. Must be the same as the user id.
ProjectMember *newProjectMember = ; // Project member details to add. State will be ignored and set to pending.

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

// Add an existing user to a project.
[apiInstance addProjectMemberWith:authorization
    pid:pid
    mid:mid
    newProjectMember:newProjectMember
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id to add the member to

var mid = mid_example; // {String} project member id to add. Must be the same as the user id.

var newProjectMember = ; // {ProjectMember} Project member details to add. State will be ignored and set to pending.


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.addProjectMember(authorization, pid, mid, newProjectMember, callback);

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

namespace Example
{
    public class addProjectMemberExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id to add the member to
            var mid = mid_example;  // String | project member id to add. Must be the same as the user id.
            var newProjectMember = new ProjectMember(); // ProjectMember | Project member details to add. State will be ignored and set to pending.

            try
            {
                // Add an existing user to a project.
                apiInstance.addProjectMember(authorization, pid, mid, newProjectMember);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.addProjectMember: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id to add the member to
$mid = mid_example; // String | project member id to add. Must be the same as the user id.
$newProjectMember = ; // ProjectMember | Project member details to add. State will be ignored and set to pending.

try {
    $api_instance->addProjectMember($authorization, $pid, $mid, $newProjectMember);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->addProjectMember: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id to add the member to
my $mid = mid_example; # String | project member id to add. Must be the same as the user id.
my $newProjectMember = WWW::SwaggerClient::Object::ProjectMember->new(); # ProjectMember | Project member details to add. State will be ignored and set to pending.

eval { 
    $api_instance->addProjectMember(authorization => $authorization, pid => $pid, mid => $mid, newProjectMember => $newProjectMember);
};
if ($@) {
    warn "Exception when calling DefaultApi->addProjectMember: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id to add the member to
mid = mid_example # String | project member id to add. Must be the same as the user id.
newProjectMember =  # ProjectMember | Project member details to add. State will be ignored and set to pending.

try: 
    # Add an existing user to a project.
    api_instance.add_project_member(authorization, pid, mid, newProjectMember)
except ApiException as e:
    print("Exception when calling DefaultApi->addProjectMember: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to add the project to
        String xid = xid_example; // String | project id to add to the pool
        try {
            apiInstance.addProjectToPool(authorization, pid, xid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#addProjectToPool");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to add the project to
        String xid = xid_example; // String | project id to add to the pool
        try {
            apiInstance.addProjectToPool(authorization, pid, xid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#addProjectToPool");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // pool id to add the project to
String *xid = xid_example; // project id to add to the pool

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

// Add a project to the pool
[apiInstance addProjectToPoolWith:authorization
    pid:pid
    xid:xid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} pool id to add the project to

var xid = xid_example; // {String} project id to add to the pool


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

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

namespace Example
{
    public class addProjectToPoolExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | pool id to add the project to
            var xid = xid_example;  // String | project id to add to the pool

            try
            {
                // Add a project to the pool
                apiInstance.addProjectToPool(authorization, pid, xid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.addProjectToPool: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | pool id to add the project to
$xid = xid_example; // String | project id to add to the pool

try {
    $api_instance->addProjectToPool($authorization, $pid, $xid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->addProjectToPool: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | pool id to add the project to
my $xid = xid_example; # String | project id to add to the pool

eval { 
    $api_instance->addProjectToPool(authorization => $authorization, pid => $pid, xid => $xid);
};
if ($@) {
    warn "Exception when calling DefaultApi->addProjectToPool: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | pool id to add the project to
xid = xid_example # String | project id to add to the pool

try: 
    # Add a project to the pool
    api_instance.add_project_to_pool(authorization, pid, xid)
except ApiException as e:
    print("Exception when calling DefaultApi->addProjectToPool: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to add the site to
        String sid = sid_example; // String | site id to add to the pool
        try {
            apiInstance.addSiteToPool(authorization, pid, sid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#addSiteToPool");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to add the site to
        String sid = sid_example; // String | site id to add to the pool
        try {
            apiInstance.addSiteToPool(authorization, pid, sid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#addSiteToPool");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // pool id to add the site to
String *sid = sid_example; // site id to add to the pool

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

// Add a site to the pool
[apiInstance addSiteToPoolWith:authorization
    pid:pid
    sid:sid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} pool id to add the site to

var sid = sid_example; // {String} site id to add to the pool


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

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

namespace Example
{
    public class addSiteToPoolExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | pool id to add the site to
            var sid = sid_example;  // String | site id to add to the pool

            try
            {
                // Add a site to the pool
                apiInstance.addSiteToPool(authorization, pid, sid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.addSiteToPool: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | pool id to add the site to
$sid = sid_example; // String | site id to add to the pool

try {
    $api_instance->addSiteToPool($authorization, $pid, $sid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->addSiteToPool: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | pool id to add the site to
my $sid = sid_example; # String | site id to add to the pool

eval { 
    $api_instance->addSiteToPool(authorization => $authorization, pid => $pid, sid => $sid);
};
if ($@) {
    warn "Exception when calling DefaultApi->addSiteToPool: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | pool id to add the site to
sid = sid_example # String | site id to add to the pool

try: 
    # Add a site to the pool
    api_instance.add_site_to_pool(authorization, pid, sid)
except ApiException as e:
    print("Exception when calling DefaultApi->addSiteToPool: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String uid = uid_example; // String | the id of the user
        AddPublicKey key = ; // AddPublicKey | key to add
        try {
            apiInstance.addUserPublicKey(authorization, uid, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#addUserPublicKey");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String uid = uid_example; // String | the id of the user
        AddPublicKey key = ; // AddPublicKey | key to add
        try {
            apiInstance.addUserPublicKey(authorization, uid, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#addUserPublicKey");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *uid = uid_example; // the id of the user
AddPublicKey *key = ; // key to add

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

// Add a public key to a user's workspace.
[apiInstance addUserPublicKeyWith:authorization
    uid:uid
    key:key
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var uid = uid_example; // {String} the id of the user

var key = ; // {AddPublicKey} key to add


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

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

namespace Example
{
    public class addUserPublicKeyExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var uid = uid_example;  // String | the id of the user
            var key = new AddPublicKey(); // AddPublicKey | key to add

            try
            {
                // Add a public key to a user's workspace.
                apiInstance.addUserPublicKey(authorization, uid, key);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.addUserPublicKey: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$uid = uid_example; // String | the id of the user
$key = ; // AddPublicKey | key to add

try {
    $api_instance->addUserPublicKey($authorization, $uid, $key);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->addUserPublicKey: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $uid = uid_example; # String | the id of the user
my $key = WWW::SwaggerClient::Object::AddPublicKey->new(); # AddPublicKey | key to add

eval { 
    $api_instance->addUserPublicKey(authorization => $authorization, uid => $uid, key => $key);
};
if ($@) {
    warn "Exception when calling DefaultApi->addUserPublicKey: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
uid = uid_example # String | the id of the user
key =  # AddPublicKey | key to add

try: 
    # Add a public key to a user's workspace.
    api_instance.add_user_public_key(authorization, uid, key)
except ApiException as e:
    print("Exception when calling DefaultApi->addUserPublicKey: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        AnonModel model = ; // AnonModel | 
        try {
            XIR result = apiInstance.compileModel(authorization, model);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#compileModel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        AnonModel model = ; // AnonModel | 
        try {
            XIR result = apiInstance.compileModel(authorization, model);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#compileModel");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
AnonModel *model = ; // 

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

// Compile the given progromatic model and return the generated XIR
[apiInstance compileModelWith:authorization
    model:model
              completionHandler: ^(XIR output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var model = ; // {AnonModel} 


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

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

namespace Example
{
    public class compileModelExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var model = new AnonModel(); // AnonModel | 

            try
            {
                // Compile the given progromatic model and return the generated XIR
                XIR result = apiInstance.compileModel(authorization, model);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.compileModel: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$model = ; // AnonModel | 

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $model = WWW::SwaggerClient::Object::AnonModel->new(); # AnonModel | 

eval { 
    my $result = $api_instance->compileModel(authorization => $authorization, model => $model);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->compileModel: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
model =  # AnonModel | 

try: 
    # Compile the given progromatic model and return the generated XIR
    api_response = api_instance.compile_model(authorization, model)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->compileModel: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String xdcid = xdcid_example; // String | name/id of the xdc
        String rid = rid_example; // String | The realization id of the materialization
        try {
            apiInstance.createClientContainerConnection(authorization, pid, eid, xdcid, rid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createClientContainerConnection");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String xdcid = xdcid_example; // String | name/id of the xdc
        String rid = rid_example; // String | The realization id of the materialization
        try {
            apiInstance.createClientContainerConnection(authorization, pid, eid, xdcid, rid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createClientContainerConnection");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id
String *eid = eid_example; // experiment id
String *xdcid = xdcid_example; // name/id of the xdc
String *rid = rid_example; // The realization id of the materialization

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

// Create the client side of a connection to an active materialization.

[apiInstance createClientContainerConnectionWith:authorization
    pid:pid
    eid:eid
    xdcid:xdcid
    rid:rid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id

var eid = eid_example; // {String} experiment id

var xdcid = xdcid_example; // {String} name/id of the xdc

var rid = rid_example; // {String} The realization id of the materialization


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createClientContainerConnection(authorization, pid, eid, xdcid, rid, callback);

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

namespace Example
{
    public class createClientContainerConnectionExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id
            var eid = eid_example;  // String | experiment id
            var xdcid = xdcid_example;  // String | name/id of the xdc
            var rid = rid_example;  // String | The realization id of the materialization

            try
            {
                // Create the client side of a connection to an active materialization.

                apiInstance.createClientContainerConnection(authorization, pid, eid, xdcid, rid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createClientContainerConnection: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id
$eid = eid_example; // String | experiment id
$xdcid = xdcid_example; // String | name/id of the xdc
$rid = rid_example; // String | The realization id of the materialization

try {
    $api_instance->createClientContainerConnection($authorization, $pid, $eid, $xdcid, $rid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createClientContainerConnection: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id
my $eid = eid_example; # String | experiment id
my $xdcid = xdcid_example; # String | name/id of the xdc
my $rid = rid_example; # String | The realization id of the materialization

eval { 
    $api_instance->createClientContainerConnection(authorization => $authorization, pid => $pid, eid => $eid, xdcid => $xdcid, rid => $rid);
};
if ($@) {
    warn "Exception when calling DefaultApi->createClientContainerConnection: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id
eid = eid_example # String | experiment id
xdcid = xdcid_example # String | name/id of the xdc
rid = rid_example # String | The realization id of the materialization

try: 
    # Create the client side of a connection to an active materialization.

    api_instance.create_client_container_connection(authorization, pid, eid, xdcid, rid)
except ApiException as e:
    print("Exception when calling DefaultApi->createClientContainerConnection: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        NewExperiment newExperiment = ; // NewExperiment | Experiment to create
        try {
            apiInstance.createExperiment(authorization, pid, eid, newExperiment);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createExperiment");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        NewExperiment newExperiment = ; // NewExperiment | Experiment to create
        try {
            apiInstance.createExperiment(authorization, pid, eid, newExperiment);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createExperiment");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment to create
NewExperiment *newExperiment = ; // Experiment to create

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

// Create a new experiment
[apiInstance createExperimentWith:authorization
    pid:pid
    eid:eid
    newExperiment:newExperiment
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment to create

var newExperiment = ; // {NewExperiment} Experiment to create


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createExperiment(authorization, pid, eid, newExperiment, callback);

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

namespace Example
{
    public class createExperimentExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment to create
            var newExperiment = new NewExperiment(); // NewExperiment | Experiment to create

            try
            {
                // Create a new experiment
                apiInstance.createExperiment(authorization, pid, eid, newExperiment);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createExperiment: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment to create
$newExperiment = ; // NewExperiment | Experiment to create

try {
    $api_instance->createExperiment($authorization, $pid, $eid, $newExperiment);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createExperiment: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment to create
my $newExperiment = WWW::SwaggerClient::Object::NewExperiment->new(); # NewExperiment | Experiment to create

eval { 
    $api_instance->createExperiment(authorization => $authorization, pid => $pid, eid => $eid, newExperiment => $newExperiment);
};
if ($@) {
    warn "Exception when calling DefaultApi->createExperiment: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment to create
newExperiment =  # NewExperiment | Experiment to create

try: 
    # Create a new experiment
    api_instance.create_experiment(authorization, pid, eid, newExperiment)
except ApiException as e:
    print("Exception when calling DefaultApi->createExperiment: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String rid = rid_example; // String | realization id
        try {
            apiInstance.createMaterialization(authorization, pid, eid, rid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createMaterialization");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String rid = rid_example; // String | realization id
        try {
            apiInstance.createMaterialization(authorization, pid, eid, rid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createMaterialization");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id
String *eid = eid_example; // experiment id
String *rid = rid_example; // realization id

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

// Create a materialization
[apiInstance createMaterializationWith:authorization
    pid:pid
    eid:eid
    rid:rid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id

var eid = eid_example; // {String} experiment id

var rid = rid_example; // {String} realization id


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createMaterialization(authorization, pid, eid, rid, callback);

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

namespace Example
{
    public class createMaterializationExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id
            var eid = eid_example;  // String | experiment id
            var rid = rid_example;  // String | realization id

            try
            {
                // Create a materialization
                apiInstance.createMaterialization(authorization, pid, eid, rid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createMaterialization: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id
$eid = eid_example; // String | experiment id
$rid = rid_example; // String | realization id

try {
    $api_instance->createMaterialization($authorization, $pid, $eid, $rid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createMaterialization: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id
my $eid = eid_example; # String | experiment id
my $rid = rid_example; # String | realization id

eval { 
    $api_instance->createMaterialization(authorization => $authorization, pid => $pid, eid => $eid, rid => $rid);
};
if ($@) {
    warn "Exception when calling DefaultApi->createMaterialization: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id
eid = eid_example # String | experiment id
rid = rid_example # String | realization id

try: 
    # Create a materialization
    api_instance.create_materialization(authorization, pid, eid, rid)
except ApiException as e:
    print("Exception when calling DefaultApi->createMaterialization: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to create
        Pool newPool = ; // Pool | Pool to create
        try {
            RegisterResponse result = apiInstance.createPool(authorization, pid, newPool);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createPool");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to create
        Pool newPool = ; // Pool | Pool to create
        try {
            RegisterResponse result = apiInstance.createPool(authorization, pid, newPool);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createPool");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // pool id to create
Pool *newPool = ; // Pool to create

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

// Create a new pool
[apiInstance createPoolWith:authorization
    pid:pid
    newPool:newPool
              completionHandler: ^(RegisterResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} pool id to create

var newPool = ; // {Pool} Pool to create


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

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

namespace Example
{
    public class createPoolExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | pool id to create
            var newPool = new Pool(); // Pool | Pool to create

            try
            {
                // Create a new pool
                RegisterResponse result = apiInstance.createPool(authorization, pid, newPool);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createPool: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | pool id to create
$newPool = ; // Pool | Pool to create

try {
    $result = $api_instance->createPool($authorization, $pid, $newPool);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createPool: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | pool id to create
my $newPool = WWW::SwaggerClient::Object::Pool->new(); # Pool | Pool to create

eval { 
    my $result = $api_instance->createPool(authorization => $authorization, pid => $pid, newPool => $newPool);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createPool: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | pool id to create
newPool =  # Pool | Pool to create

try: 
    # Create a new pool
    api_response = api_instance.create_pool(authorization, pid, newPool)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createPool: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to create
        Project newProject = ; // Project | Project to add
        try {
            apiInstance.createProject(authorization, pid, newProject);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createProject");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to create
        Project newProject = ; // Project | Project to add
        try {
            apiInstance.createProject(authorization, pid, newProject);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createProject");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id to create
Project *newProject = ; // Project to add

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

// Create a new project
[apiInstance createProjectWith:authorization
    pid:pid
    newProject:newProject
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id to create

var newProject = ; // {Project} Project to add


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

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

namespace Example
{
    public class createProjectExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id to create
            var newProject = new Project(); // Project | Project to add

            try
            {
                // Create a new project
                apiInstance.createProject(authorization, pid, newProject);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createProject: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id to create
$newProject = ; // Project | Project to add

try {
    $api_instance->createProject($authorization, $pid, $newProject);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createProject: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id to create
my $newProject = WWW::SwaggerClient::Object::Project->new(); # Project | Project to add

eval { 
    $api_instance->createProject(authorization => $authorization, pid => $pid, newProject => $newProject);
};
if ($@) {
    warn "Exception when calling DefaultApi->createProject: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id to create
newProject =  # Project | Project to add

try: 
    # Create a new project
    api_instance.create_project(authorization, pid, newProject)
except ApiException as e:
    print("Exception when calling DefaultApi->createProject: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to which the realization belongs
        String rid = rid_example; // String | id of the realization to create
        NewRealization newRealization = ; // NewRealization | Realization to create
        try {
            RealizeResponse result = apiInstance.createRealization(authorization, pid, eid, rid, newRealization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createRealization");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to which the realization belongs
        String rid = rid_example; // String | id of the realization to create
        NewRealization newRealization = ; // NewRealization | Realization to create
        try {
            RealizeResponse result = apiInstance.createRealization(authorization, pid, eid, rid, newRealization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createRealization");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment to which the realization belongs
String *rid = rid_example; // id of the realization to create
NewRealization *newRealization = ; // Realization to create

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

// Create a realization
[apiInstance createRealizationWith:authorization
    pid:pid
    eid:eid
    rid:rid
    newRealization:newRealization
              completionHandler: ^(RealizeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment to which the realization belongs

var rid = rid_example; // {String} id of the realization to create

var newRealization = ; // {NewRealization} Realization to create


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createRealization(authorization, pid, eid, rid, newRealization, callback);

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

namespace Example
{
    public class createRealizationExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment to which the realization belongs
            var rid = rid_example;  // String | id of the realization to create
            var newRealization = new NewRealization(); // NewRealization | Realization to create

            try
            {
                // Create a realization
                RealizeResponse result = apiInstance.createRealization(authorization, pid, eid, rid, newRealization);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createRealization: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment to which the realization belongs
$rid = rid_example; // String | id of the realization to create
$newRealization = ; // NewRealization | Realization to create

try {
    $result = $api_instance->createRealization($authorization, $pid, $eid, $rid, $newRealization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createRealization: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment to which the realization belongs
my $rid = rid_example; # String | id of the realization to create
my $newRealization = WWW::SwaggerClient::Object::NewRealization->new(); # NewRealization | Realization to create

eval { 
    my $result = $api_instance->createRealization(authorization => $authorization, pid => $pid, eid => $eid, rid => $rid, newRealization => $newRealization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createRealization: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment to which the realization belongs
rid = rid_example # String | id of the realization to create
newRealization =  # NewRealization | Realization to create

try: 
    # Create a realization
    api_response = api_instance.create_realization(authorization, pid, eid, rid, newRealization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createRealization: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to update
        array[String] resources = ; // array[String] | resources to deactivate
        try {
            apiInstance.deactivateResources(authorization, sid, resources);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deactivateResources");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to update
        array[String] resources = ; // array[String] | resources to deactivate
        try {
            apiInstance.deactivateResources(authorization, sid, resources);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deactivateResources");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *sid = sid_example; // site id to update
array[String] *resources = ; // resources to deactivate (optional)

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

// Deactivate a set of resources
[apiInstance deactivateResourcesWith:authorization
    sid:sid
    resources:resources
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var sid = sid_example; // {String} site id to update

var opts = { 
  'resources':  // {array[String]} resources to deactivate
};

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

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

namespace Example
{
    public class deactivateResourcesExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var sid = sid_example;  // String | site id to update
            var resources = new array[String](); // array[String] | resources to deactivate (optional) 

            try
            {
                // Deactivate a set of resources
                apiInstance.deactivateResources(authorization, sid, resources);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deactivateResources: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$sid = sid_example; // String | site id to update
$resources = ; // array[String] | resources to deactivate

try {
    $api_instance->deactivateResources($authorization, $sid, $resources);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deactivateResources: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $sid = sid_example; # String | site id to update
my $resources = [WWW::SwaggerClient::Object::array[String]->new()]; # array[String] | resources to deactivate

eval { 
    $api_instance->deactivateResources(authorization => $authorization, sid => $sid, resources => $resources);
};
if ($@) {
    warn "Exception when calling DefaultApi->deactivateResources: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
sid = sid_example # String | site id to update
resources =  # array[String] | resources to deactivate (optional)

try: 
    # Deactivate a set of resources
    api_instance.deactivate_resources(authorization, sid, resources=resources)
except ApiException as e:
    print("Exception when calling DefaultApi->deactivateResources: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to which the realization belongs
        String rid = rid_example; // String | id of the realization to update
        RealizationAction body = ; // RealizationAction | What to do with realization
        try {
            apiInstance.decideRealization(authorization, pid, eid, rid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#decideRealization");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to which the realization belongs
        String rid = rid_example; // String | id of the realization to update
        RealizationAction body = ; // RealizationAction | What to do with realization
        try {
            apiInstance.decideRealization(authorization, pid, eid, rid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#decideRealization");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment to which the realization belongs
String *rid = rid_example; // id of the realization to update
RealizationAction *body = ; // What to do with realization

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

// Act on a realization (accept or reject)
[apiInstance decideRealizationWith:authorization
    pid:pid
    eid:eid
    rid:rid
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment to which the realization belongs

var rid = rid_example; // {String} id of the realization to update

var body = ; // {RealizationAction} What to do with realization


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.decideRealization(authorization, pid, eid, rid, body, callback);

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

namespace Example
{
    public class decideRealizationExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment to which the realization belongs
            var rid = rid_example;  // String | id of the realization to update
            var body = new RealizationAction(); // RealizationAction | What to do with realization

            try
            {
                // Act on a realization (accept or reject)
                apiInstance.decideRealization(authorization, pid, eid, rid, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.decideRealization: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment to which the realization belongs
$rid = rid_example; // String | id of the realization to update
$body = ; // RealizationAction | What to do with realization

try {
    $api_instance->decideRealization($authorization, $pid, $eid, $rid, $body);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->decideRealization: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment to which the realization belongs
my $rid = rid_example; # String | id of the realization to update
my $body = WWW::SwaggerClient::Object::RealizationAction->new(); # RealizationAction | What to do with realization

eval { 
    $api_instance->decideRealization(authorization => $authorization, pid => $pid, eid => $eid, rid => $rid, body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->decideRealization: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment to which the realization belongs
rid = rid_example # String | id of the realization to update
body =  # RealizationAction | What to do with realization

try: 
    # Act on a realization (accept or reject)
    api_instance.decide_realization(authorization, pid, eid, rid, body)
except ApiException as e:
    print("Exception when calling DefaultApi->decideRealization: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String xdcid = xdcid_example; // String | name/id of the xdc
        String rid = rid_example; // String | The realization id of the materialization
        try {
            apiInstance.deleteClientContainerConnection(authorization, pid, eid, xdcid, rid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteClientContainerConnection");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String xdcid = xdcid_example; // String | name/id of the xdc
        String rid = rid_example; // String | The realization id of the materialization
        try {
            apiInstance.deleteClientContainerConnection(authorization, pid, eid, xdcid, rid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteClientContainerConnection");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id
String *eid = eid_example; // experiment id
String *xdcid = xdcid_example; // name/id of the xdc
String *rid = rid_example; // The realization id of the materialization

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

// Delete the client side of a connection to a materialization.

[apiInstance deleteClientContainerConnectionWith:authorization
    pid:pid
    eid:eid
    xdcid:xdcid
    rid:rid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id

var eid = eid_example; // {String} experiment id

var xdcid = xdcid_example; // {String} name/id of the xdc

var rid = rid_example; // {String} The realization id of the materialization


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteClientContainerConnection(authorization, pid, eid, xdcid, rid, callback);

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

namespace Example
{
    public class deleteClientContainerConnectionExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id
            var eid = eid_example;  // String | experiment id
            var xdcid = xdcid_example;  // String | name/id of the xdc
            var rid = rid_example;  // String | The realization id of the materialization

            try
            {
                // Delete the client side of a connection to a materialization.

                apiInstance.deleteClientContainerConnection(authorization, pid, eid, xdcid, rid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteClientContainerConnection: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id
$eid = eid_example; // String | experiment id
$xdcid = xdcid_example; // String | name/id of the xdc
$rid = rid_example; // String | The realization id of the materialization

try {
    $api_instance->deleteClientContainerConnection($authorization, $pid, $eid, $xdcid, $rid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteClientContainerConnection: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id
my $eid = eid_example; # String | experiment id
my $xdcid = xdcid_example; # String | name/id of the xdc
my $rid = rid_example; # String | The realization id of the materialization

eval { 
    $api_instance->deleteClientContainerConnection(authorization => $authorization, pid => $pid, eid => $eid, xdcid => $xdcid, rid => $rid);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteClientContainerConnection: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id
eid = eid_example # String | experiment id
xdcid = xdcid_example # String | name/id of the xdc
rid = rid_example # String | The realization id of the materialization

try: 
    # Delete the client side of a connection to a materialization.

    api_instance.delete_client_container_connection(authorization, pid, eid, xdcid, rid)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteClientContainerConnection: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        try {
            apiInstance.deleteExperiment(authorization, pid, eid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteExperiment");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        try {
            apiInstance.deleteExperiment(authorization, pid, eid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteExperiment");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment to create

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

// Deletes an experiment
[apiInstance deleteExperimentWith:authorization
    pid:pid
    eid:eid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment to create


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

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

namespace Example
{
    public class deleteExperimentExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment to create

            try
            {
                // Deletes an experiment
                apiInstance.deleteExperiment(authorization, pid, eid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteExperiment: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment to create

try {
    $api_instance->deleteExperiment($authorization, $pid, $eid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteExperiment: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment to create

eval { 
    $api_instance->deleteExperiment(authorization => $authorization, pid => $pid, eid => $eid);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteExperiment: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment to create

try: 
    # Deletes an experiment
    api_instance.delete_experiment(authorization, pid, eid)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteExperiment: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String rid = rid_example; // String | realization id
        try {
            apiInstance.deleteMaterialization(authorization, pid, eid, rid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteMaterialization");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String rid = rid_example; // String | realization id
        try {
            apiInstance.deleteMaterialization(authorization, pid, eid, rid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteMaterialization");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id
String *eid = eid_example; // experiment id
String *rid = rid_example; // realization id

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

// Delete a materialization
[apiInstance deleteMaterializationWith:authorization
    pid:pid
    eid:eid
    rid:rid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id

var eid = eid_example; // {String} experiment id

var rid = rid_example; // {String} realization id


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteMaterialization(authorization, pid, eid, rid, callback);

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

namespace Example
{
    public class deleteMaterializationExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id
            var eid = eid_example;  // String | experiment id
            var rid = rid_example;  // String | realization id

            try
            {
                // Delete a materialization
                apiInstance.deleteMaterialization(authorization, pid, eid, rid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteMaterialization: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id
$eid = eid_example; // String | experiment id
$rid = rid_example; // String | realization id

try {
    $api_instance->deleteMaterialization($authorization, $pid, $eid, $rid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteMaterialization: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id
my $eid = eid_example; # String | experiment id
my $rid = rid_example; # String | realization id

eval { 
    $api_instance->deleteMaterialization(authorization => $authorization, pid => $pid, eid => $eid, rid => $rid);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteMaterialization: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id
eid = eid_example # String | experiment id
rid = rid_example # String | realization id

try: 
    # Delete a materialization
    api_instance.delete_materialization(authorization, pid, eid, rid)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteMaterialization: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to delete
        try {
            RegisterResponse result = apiInstance.deletePool(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deletePool");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to delete
        try {
            RegisterResponse result = apiInstance.deletePool(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deletePool");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // pool id to delete

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

// Deletes a pool
[apiInstance deletePoolWith:authorization
    pid:pid
              completionHandler: ^(RegisterResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} pool id to delete


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

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

namespace Example
{
    public class deletePoolExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | pool id to delete

            try
            {
                // Deletes a pool
                RegisterResponse result = apiInstance.deletePool(authorization, pid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deletePool: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | pool id to delete

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | pool id to delete

eval { 
    my $result = $api_instance->deletePool(authorization => $authorization, pid => $pid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->deletePool: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | pool id to delete

try: 
    # Deletes a pool
    api_response = api_instance.delete_pool(authorization, pid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->deletePool: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to delete
        try {
            apiInstance.deleteProject(authorization, pid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteProject");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to delete
        try {
            apiInstance.deleteProject(authorization, pid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteProject");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id to delete

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

// Deletes a project
[apiInstance deleteProjectWith:authorization
    pid:pid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id to delete


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

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

namespace Example
{
    public class deleteProjectExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id to delete

            try
            {
                // Deletes a project
                apiInstance.deleteProject(authorization, pid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteProject: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id to delete

try {
    $api_instance->deleteProject($authorization, $pid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteProject: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id to delete

eval { 
    $api_instance->deleteProject(authorization => $authorization, pid => $pid);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteProject: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id to delete

try: 
    # Deletes a project
    api_instance.delete_project(authorization, pid)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteProject: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to remove project from
        String xid = xid_example; // String | project id to remove from the pool
        try {
            apiInstance.deleteProjectFromPool(authorization, pid, xid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteProjectFromPool");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to remove project from
        String xid = xid_example; // String | project id to remove from the pool
        try {
            apiInstance.deleteProjectFromPool(authorization, pid, xid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteProjectFromPool");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // pool id to remove project from
String *xid = xid_example; // project id to remove from the pool

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

// Remove a project from the pool
[apiInstance deleteProjectFromPoolWith:authorization
    pid:pid
    xid:xid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} pool id to remove project from

var xid = xid_example; // {String} project id to remove from the pool


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

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

namespace Example
{
    public class deleteProjectFromPoolExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | pool id to remove project from
            var xid = xid_example;  // String | project id to remove from the pool

            try
            {
                // Remove a project from the pool
                apiInstance.deleteProjectFromPool(authorization, pid, xid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteProjectFromPool: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | pool id to remove project from
$xid = xid_example; // String | project id to remove from the pool

try {
    $api_instance->deleteProjectFromPool($authorization, $pid, $xid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteProjectFromPool: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | pool id to remove project from
my $xid = xid_example; # String | project id to remove from the pool

eval { 
    $api_instance->deleteProjectFromPool(authorization => $authorization, pid => $pid, xid => $xid);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteProjectFromPool: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | pool id to remove project from
xid = xid_example # String | project id to remove from the pool

try: 
    # Remove a project from the pool
    api_instance.delete_project_from_pool(authorization, pid, xid)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteProjectFromPool: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to reference
        String mid = mid_example; // String | project member id to delete
        try {
            apiInstance.deleteProjectMember(authorization, pid, mid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteProjectMember");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to reference
        String mid = mid_example; // String | project member id to delete
        try {
            apiInstance.deleteProjectMember(authorization, pid, mid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteProjectMember");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id to reference
String *mid = mid_example; // project member id to delete

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

// Removes a member from a project
[apiInstance deleteProjectMemberWith:authorization
    pid:pid
    mid:mid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id to reference

var mid = mid_example; // {String} project member id to delete


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

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

namespace Example
{
    public class deleteProjectMemberExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id to reference
            var mid = mid_example;  // String | project member id to delete

            try
            {
                // Removes a member from a project
                apiInstance.deleteProjectMember(authorization, pid, mid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteProjectMember: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id to reference
$mid = mid_example; // String | project member id to delete

try {
    $api_instance->deleteProjectMember($authorization, $pid, $mid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteProjectMember: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id to reference
my $mid = mid_example; # String | project member id to delete

eval { 
    $api_instance->deleteProjectMember(authorization => $authorization, pid => $pid, mid => $mid);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteProjectMember: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id to reference
mid = mid_example # String | project member id to delete

try: 
    # Removes a member from a project
    api_instance.delete_project_member(authorization, pid, mid)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteProjectMember: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to which the realization belongs
        String rid = rid_example; // String | id of the realization to delete
        try {
            apiInstance.deleteRealization(authorization, pid, eid, rid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteRealization");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to which the realization belongs
        String rid = rid_example; // String | id of the realization to delete
        try {
            apiInstance.deleteRealization(authorization, pid, eid, rid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteRealization");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment to which the realization belongs
String *rid = rid_example; // id of the realization to delete

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

// Delete a realization
[apiInstance deleteRealizationWith:authorization
    pid:pid
    eid:eid
    rid:rid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment to which the realization belongs

var rid = rid_example; // {String} id of the realization to delete


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteRealization(authorization, pid, eid, rid, callback);

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

namespace Example
{
    public class deleteRealizationExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment to which the realization belongs
            var rid = rid_example;  // String | id of the realization to delete

            try
            {
                // Delete a realization
                apiInstance.deleteRealization(authorization, pid, eid, rid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteRealization: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment to which the realization belongs
$rid = rid_example; // String | id of the realization to delete

try {
    $api_instance->deleteRealization($authorization, $pid, $eid, $rid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteRealization: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment to which the realization belongs
my $rid = rid_example; # String | id of the realization to delete

eval { 
    $api_instance->deleteRealization(authorization => $authorization, pid => $pid, eid => $eid, rid => $rid);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteRealization: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment to which the realization belongs
rid = rid_example # String | id of the realization to delete

try: 
    # Delete a realization
    api_instance.delete_realization(authorization, pid, eid, rid)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteRealization: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to remove site from
        String sid = sid_example; // String | site id to remove from the pool
        try {
            apiInstance.deleteSiteFromPool(authorization, pid, sid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteSiteFromPool");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to remove site from
        String sid = sid_example; // String | site id to remove from the pool
        try {
            apiInstance.deleteSiteFromPool(authorization, pid, sid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteSiteFromPool");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // pool id to remove site from
String *sid = sid_example; // site id to remove from the pool

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

// Remove a site from the pool
[apiInstance deleteSiteFromPoolWith:authorization
    pid:pid
    sid:sid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} pool id to remove site from

var sid = sid_example; // {String} site id to remove from the pool


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

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

namespace Example
{
    public class deleteSiteFromPoolExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | pool id to remove site from
            var sid = sid_example;  // String | site id to remove from the pool

            try
            {
                // Remove a site from the pool
                apiInstance.deleteSiteFromPool(authorization, pid, sid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteSiteFromPool: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | pool id to remove site from
$sid = sid_example; // String | site id to remove from the pool

try {
    $api_instance->deleteSiteFromPool($authorization, $pid, $sid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteSiteFromPool: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | pool id to remove site from
my $sid = sid_example; # String | site id to remove from the pool

eval { 
    $api_instance->deleteSiteFromPool(authorization => $authorization, pid => $pid, sid => $sid);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteSiteFromPool: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | pool id to remove site from
sid = sid_example # String | site id to remove from the pool

try: 
    # Remove a site from the pool
    api_instance.delete_site_from_pool(authorization, pid, sid)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteSiteFromPool: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String uid = uid_example; // String | user id to delete
        try {
            apiInstance.deleteUser(authorization, uid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String uid = uid_example; // String | user id to delete
        try {
            apiInstance.deleteUser(authorization, uid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteUser");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *uid = uid_example; // user id to delete

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

// Deletes a user
[apiInstance deleteUserWith:authorization
    uid:uid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var uid = uid_example; // {String} user id to delete


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

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

namespace Example
{
    public class deleteUserExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var uid = uid_example;  // String | user id to delete

            try
            {
                // Deletes a user
                apiInstance.deleteUser(authorization, uid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteUser: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$uid = uid_example; // String | user id to delete

try {
    $api_instance->deleteUser($authorization, $uid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteUser: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $uid = uid_example; # String | user id to delete

eval { 
    $api_instance->deleteUser(authorization => $authorization, uid => $uid);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteUser: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
uid = uid_example # String | user id to delete

try: 
    # Deletes a user
    api_instance.delete_user(authorization, uid)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteUser: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String uid = uid_example; // String | the id of the user
        String fingerprint = fingerprint_example; // String | md5 style fingerprint of the key to remove.
        try {
            apiInstance.deleteUserPublicKey(authorization, uid, fingerprint);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteUserPublicKey");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String uid = uid_example; // String | the id of the user
        String fingerprint = fingerprint_example; // String | md5 style fingerprint of the key to remove.
        try {
            apiInstance.deleteUserPublicKey(authorization, uid, fingerprint);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteUserPublicKey");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *uid = uid_example; // the id of the user
String *fingerprint = fingerprint_example; // md5 style fingerprint of the key to remove.

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

// Removes a public key from a user's workspace.
[apiInstance deleteUserPublicKeyWith:authorization
    uid:uid
    fingerprint:fingerprint
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var uid = uid_example; // {String} the id of the user

var fingerprint = fingerprint_example; // {String} md5 style fingerprint of the key to remove.


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

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

namespace Example
{
    public class deleteUserPublicKeyExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var uid = uid_example;  // String | the id of the user
            var fingerprint = fingerprint_example;  // String | md5 style fingerprint of the key to remove.

            try
            {
                // Removes a public key from a user's workspace.
                apiInstance.deleteUserPublicKey(authorization, uid, fingerprint);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteUserPublicKey: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$uid = uid_example; // String | the id of the user
$fingerprint = fingerprint_example; // String | md5 style fingerprint of the key to remove.

try {
    $api_instance->deleteUserPublicKey($authorization, $uid, $fingerprint);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteUserPublicKey: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $uid = uid_example; # String | the id of the user
my $fingerprint = fingerprint_example; # String | md5 style fingerprint of the key to remove.

eval { 
    $api_instance->deleteUserPublicKey(authorization => $authorization, uid => $uid, fingerprint => $fingerprint);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteUserPublicKey: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
uid = uid_example # String | the id of the user
fingerprint = fingerprint_example # String | md5 style fingerprint of the key to remove.

try: 
    # Removes a public key from a user's workspace.
    api_instance.delete_user_public_key(authorization, uid, fingerprint)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteUserPublicKey: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to which the xdc belongs
        String xdcid = xdcid_example; // String | id of the xdc to destroy
        try {
            apiInstance.destroyXdc(authorization, pid, eid, xdcid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#destroyXdc");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to which the xdc belongs
        String xdcid = xdcid_example; // String | id of the xdc to destroy
        try {
            apiInstance.destroyXdc(authorization, pid, eid, xdcid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#destroyXdc");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment to which the xdc belongs
String *xdcid = xdcid_example; // id of the xdc to destroy

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

// Destroy an existing experiment development container in an experiment.
[apiInstance destroyXdcWith:authorization
    pid:pid
    eid:eid
    xdcid:xdcid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment to which the xdc belongs

var xdcid = xdcid_example; // {String} id of the xdc to destroy


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.destroyXdc(authorization, pid, eid, xdcid, callback);

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

namespace Example
{
    public class destroyXdcExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment to which the xdc belongs
            var xdcid = xdcid_example;  // String | id of the xdc to destroy

            try
            {
                // Destroy an existing experiment development container in an experiment.
                apiInstance.destroyXdc(authorization, pid, eid, xdcid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.destroyXdc: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment to which the xdc belongs
$xdcid = xdcid_example; // String | id of the xdc to destroy

try {
    $api_instance->destroyXdc($authorization, $pid, $eid, $xdcid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->destroyXdc: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment to which the xdc belongs
my $xdcid = xdcid_example; # String | id of the xdc to destroy

eval { 
    $api_instance->destroyXdc(authorization => $authorization, pid => $pid, eid => $eid, xdcid => $xdcid);
};
if ($@) {
    warn "Exception when calling DefaultApi->destroyXdc: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment to which the xdc belongs
xdcid = xdcid_example # String | id of the xdc to destroy

try: 
    # Destroy an existing experiment development container in an experiment.
    api_instance.destroy_xdc(authorization, pid, eid, xdcid)
except ApiException as e:
    print("Exception when calling DefaultApi->destroyXdc: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        try {
            Experiment result = apiInstance.getExperiment(authorization, pid, eid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getExperiment");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        try {
            Experiment result = apiInstance.getExperiment(authorization, pid, eid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getExperiment");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment to create

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

// Get an experiment
[apiInstance getExperimentWith:authorization
    pid:pid
    eid:eid
              completionHandler: ^(Experiment output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment to create


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

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

namespace Example
{
    public class getExperimentExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment to create

            try
            {
                // Get an experiment
                Experiment result = apiInstance.getExperiment(authorization, pid, eid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getExperiment: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment to create

try {
    $result = $api_instance->getExperiment($authorization, $pid, $eid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getExperiment: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment to create

eval { 
    my $result = $api_instance->getExperiment(authorization => $authorization, pid => $pid, eid => $eid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getExperiment: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment to create

try: 
    # Get an experiment
    api_response = api_instance.get_experiment(authorization, pid, eid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getExperiment: %s\n" % e)

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

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

public class DefaultApiExample {

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

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

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

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

// Get API health status
[apiInstance getHealthWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

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

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

namespace Example
{
    public class getHealthExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Get API health status
                'String' result = apiInstance.getHealth();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getHealth: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try: 
    # Get API health status
    api_response = api_instance.get_health()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getHealth: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String rid = rid_example; // String | realization id
        try {
            Materialization result = apiInstance.getMaterialization(authorization, pid, eid, rid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getMaterialization");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String rid = rid_example; // String | realization id
        try {
            Materialization result = apiInstance.getMaterialization(authorization, pid, eid, rid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getMaterialization");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id
String *eid = eid_example; // experiment id
String *rid = rid_example; // realization id

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

// Get data about a materialization
[apiInstance getMaterializationWith:authorization
    pid:pid
    eid:eid
    rid:rid
              completionHandler: ^(Materialization output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id

var eid = eid_example; // {String} experiment id

var rid = rid_example; // {String} realization id


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

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

namespace Example
{
    public class getMaterializationExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id
            var eid = eid_example;  // String | experiment id
            var rid = rid_example;  // String | realization id

            try
            {
                // Get data about a materialization
                Materialization result = apiInstance.getMaterialization(authorization, pid, eid, rid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getMaterialization: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id
$eid = eid_example; // String | experiment id
$rid = rid_example; // String | realization id

try {
    $result = $api_instance->getMaterialization($authorization, $pid, $eid, $rid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getMaterialization: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id
my $eid = eid_example; # String | experiment id
my $rid = rid_example; # String | realization id

eval { 
    my $result = $api_instance->getMaterialization(authorization => $authorization, pid => $pid, eid => $eid, rid => $rid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getMaterialization: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id
eid = eid_example # String | experiment id
rid = rid_example # String | realization id

try: 
    # Get data about a materialization
    api_response = api_instance.get_materialization(authorization, pid, eid, rid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getMaterialization: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String rid = rid_example; // String | realization id
        try {
            MaterializationStatus result = apiInstance.getMaterializationStatus(authorization, pid, eid, rid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getMaterializationStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String rid = rid_example; // String | realization id
        try {
            MaterializationStatus result = apiInstance.getMaterializationStatus(authorization, pid, eid, rid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getMaterializationStatus");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id
String *eid = eid_example; // experiment id
String *rid = rid_example; // realization id

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

// Get materialization status
[apiInstance getMaterializationStatusWith:authorization
    pid:pid
    eid:eid
    rid:rid
              completionHandler: ^(MaterializationStatus output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id

var eid = eid_example; // {String} experiment id

var rid = rid_example; // {String} realization id


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

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

namespace Example
{
    public class getMaterializationStatusExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id
            var eid = eid_example;  // String | experiment id
            var rid = rid_example;  // String | realization id

            try
            {
                // Get materialization status
                MaterializationStatus result = apiInstance.getMaterializationStatus(authorization, pid, eid, rid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getMaterializationStatus: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id
$eid = eid_example; // String | experiment id
$rid = rid_example; // String | realization id

try {
    $result = $api_instance->getMaterializationStatus($authorization, $pid, $eid, $rid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getMaterializationStatus: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id
my $eid = eid_example; # String | experiment id
my $rid = rid_example; # String | realization id

eval { 
    my $result = $api_instance->getMaterializationStatus(authorization => $authorization, pid => $pid, eid => $eid, rid => $rid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getMaterializationStatus: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id
eid = eid_example # String | experiment id
rid = rid_example # String | realization id

try: 
    # Get materialization status
    api_response = api_instance.get_materialization_status(authorization, pid, eid, rid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getMaterializationStatus: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to get
        try {
            Pool result = apiInstance.getPool(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPool");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to get
        try {
            Pool result = apiInstance.getPool(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPool");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // pool id to get

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

// Get a pools info
[apiInstance getPoolWith:authorization
    pid:pid
              completionHandler: ^(Pool output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} pool id to get


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

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

namespace Example
{
    public class getPoolExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | pool id to get

            try
            {
                // Get a pools info
                Pool result = apiInstance.getPool(authorization, pid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getPool: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | pool id to get

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | pool id to get

eval { 
    my $result = $api_instance->getPool(authorization => $authorization, pid => $pid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getPool: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | pool id to get

try: 
    # Get a pools info
    api_response = api_instance.get_pool(authorization, pid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getPool: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id
        String xid = xid_example; // String | project id to set state for
        try {
            PoolProjectState result = apiInstance.getPoolProjectState(authorization, pid, xid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPoolProjectState");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id
        String xid = xid_example; // String | project id to set state for
        try {
            PoolProjectState result = apiInstance.getPoolProjectState(authorization, pid, xid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPoolProjectState");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // pool id
String *xid = xid_example; // project id to set state for

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

// Get project's pool membership state
[apiInstance getPoolProjectStateWith:authorization
    pid:pid
    xid:xid
              completionHandler: ^(PoolProjectState output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} pool id

var xid = xid_example; // {String} project id to set state for


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

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

namespace Example
{
    public class getPoolProjectStateExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | pool id
            var xid = xid_example;  // String | project id to set state for

            try
            {
                // Get project's pool membership state
                PoolProjectState result = apiInstance.getPoolProjectState(authorization, pid, xid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getPoolProjectState: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | pool id
$xid = xid_example; // String | project id to set state for

try {
    $result = $api_instance->getPoolProjectState($authorization, $pid, $xid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getPoolProjectState: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | pool id
my $xid = xid_example; # String | project id to set state for

eval { 
    my $result = $api_instance->getPoolProjectState(authorization => $authorization, pid => $pid, xid => $xid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getPoolProjectState: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | pool id
xid = xid_example # String | project id to set state for

try: 
    # Get project's pool membership state
    api_response = api_instance.get_pool_project_state(authorization, pid, xid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getPoolProjectState: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to list projects for
        try {
            array[PoolProject] result = apiInstance.getPoolProjects(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPoolProjects");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to list projects for
        try {
            array[PoolProject] result = apiInstance.getPoolProjects(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPoolProjects");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // pool id to list projects for

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

// List a pools projects
[apiInstance getPoolProjectsWith:authorization
    pid:pid
              completionHandler: ^(array[PoolProject] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} pool id to list projects for


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

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

namespace Example
{
    public class getPoolProjectsExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | pool id to list projects for

            try
            {
                // List a pools projects
                array[PoolProject] result = apiInstance.getPoolProjects(authorization, pid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getPoolProjects: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | pool id to list projects for

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | pool id to list projects for

eval { 
    my $result = $api_instance->getPoolProjects(authorization => $authorization, pid => $pid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getPoolProjects: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | pool id to list projects for

try: 
    # List a pools projects
    api_response = api_instance.get_pool_projects(authorization, pid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getPoolProjects: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to list sites for
        try {
            array[PoolSite] result = apiInstance.getPoolSites(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPoolSites");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id to list sites for
        try {
            array[PoolSite] result = apiInstance.getPoolSites(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPoolSites");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // pool id to list sites for

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

// List a pools sites
[apiInstance getPoolSitesWith:authorization
    pid:pid
              completionHandler: ^(array[PoolSite] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} pool id to list sites for


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

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

namespace Example
{
    public class getPoolSitesExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | pool id to list sites for

            try
            {
                // List a pools sites
                array[PoolSite] result = apiInstance.getPoolSites(authorization, pid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getPoolSites: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | pool id to list sites for

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | pool id to list sites for

eval { 
    my $result = $api_instance->getPoolSites(authorization => $authorization, pid => $pid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getPoolSites: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | pool id to list sites for

try: 
    # List a pools sites
    api_response = api_instance.get_pool_sites(authorization, pid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getPoolSites: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        try {
            array[Pool] result = apiInstance.getPools(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPools");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        try {
            array[Pool] result = apiInstance.getPools(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPools");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format

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

// Get pools
[apiInstance getPoolsWith:authorization
              completionHandler: ^(array[Pool] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format


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

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

namespace Example
{
    public class getPoolsExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format

            try
            {
                // Get pools
                array[Pool] result = apiInstance.getPools(authorization);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getPools: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format

eval { 
    my $result = $api_instance->getPools(authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getPools: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format

try: 
    # Get pools
    api_response = api_instance.get_pools(authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getPools: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to get
        try {
            Project result = apiInstance.getProject(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getProject");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to get
        try {
            Project result = apiInstance.getProject(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getProject");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id to get

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

// Get a projects info
[apiInstance getProjectWith:authorization
    pid:pid
              completionHandler: ^(Project output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id to get


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

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

namespace Example
{
    public class getProjectExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id to get

            try
            {
                // Get a projects info
                Project result = apiInstance.getProject(authorization, pid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getProject: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id to get

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id to get

eval { 
    my $result = $api_instance->getProject(authorization => $authorization, pid => $pid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getProject: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id to get

try: 
    # Get a projects info
    api_response = api_instance.get_project(authorization, pid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getProject: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to list experiments for
        try {
            array['String'] result = apiInstance.getProjectExperiments(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getProjectExperiments");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to list experiments for
        try {
            array['String'] result = apiInstance.getProjectExperiments(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getProjectExperiments");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id to list experiments for

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

// List a projects experiments
[apiInstance getProjectExperimentsWith:authorization
    pid:pid
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id to list experiments for


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

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

namespace Example
{
    public class getProjectExperimentsExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id to list experiments for

            try
            {
                // List a projects experiments
                array['String'] result = apiInstance.getProjectExperiments(authorization, pid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getProjectExperiments: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id to list experiments for

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id to list experiments for

eval { 
    my $result = $api_instance->getProjectExperiments(authorization => $authorization, pid => $pid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getProjectExperiments: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id to list experiments for

try: 
    # List a projects experiments
    api_response = api_instance.get_project_experiments(authorization, pid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getProjectExperiments: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id of the member
        String mid = mid_example; // String | project member id to get
        try {
            ProjectMember result = apiInstance.getProjectMember(authorization, pid, mid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getProjectMember");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id of the member
        String mid = mid_example; // String | project member id to get
        try {
            ProjectMember result = apiInstance.getProjectMember(authorization, pid, mid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getProjectMember");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id of the member
String *mid = mid_example; // project member id to get

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

// Get a projects member info
[apiInstance getProjectMemberWith:authorization
    pid:pid
    mid:mid
              completionHandler: ^(ProjectMember output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id of the member

var mid = mid_example; // {String} project member id to get


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

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

namespace Example
{
    public class getProjectMemberExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id of the member
            var mid = mid_example;  // String | project member id to get

            try
            {
                // Get a projects member info
                ProjectMember result = apiInstance.getProjectMember(authorization, pid, mid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getProjectMember: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id of the member
$mid = mid_example; // String | project member id to get

try {
    $result = $api_instance->getProjectMember($authorization, $pid, $mid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getProjectMember: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id of the member
my $mid = mid_example; # String | project member id to get

eval { 
    my $result = $api_instance->getProjectMember(authorization => $authorization, pid => $pid, mid => $mid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getProjectMember: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id of the member
mid = mid_example # String | project member id to get

try: 
    # Get a projects member info
    api_response = api_instance.get_project_member(authorization, pid, mid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getProjectMember: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to list members for
        try {
            array['String'] result = apiInstance.getProjectMembers(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getProjectMembers");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id to list members for
        try {
            array['String'] result = apiInstance.getProjectMembers(authorization, pid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getProjectMembers");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id to list members for

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

// List a projects members
[apiInstance getProjectMembersWith:authorization
    pid:pid
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id to list members for


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

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

namespace Example
{
    public class getProjectMembersExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id to list members for

            try
            {
                // List a projects members
                array['String'] result = apiInstance.getProjectMembers(authorization, pid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getProjectMembers: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id to list members for

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id to list members for

eval { 
    my $result = $api_instance->getProjectMembers(authorization => $authorization, pid => $pid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getProjectMembers: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id to list members for

try: 
    # List a projects members
    api_response = api_instance.get_project_members(authorization, pid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getProjectMembers: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        try {
            array[Project] result = apiInstance.getProjects(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getProjects");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        try {
            array[Project] result = apiInstance.getProjects(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getProjects");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format

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

// List projects
[apiInstance getProjectsWith:authorization
              completionHandler: ^(array[Project] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format


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

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

namespace Example
{
    public class getProjectsExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format

            try
            {
                // List projects
                array[Project] result = apiInstance.getProjects(authorization);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getProjects: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format

eval { 
    my $result = $api_instance->getProjects(authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getProjects: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format

try: 
    # List projects
    api_response = api_instance.get_projects(authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getProjects: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to which the realization belongs
        String rid = rid_example; // String | id of the realization to get
        try {
            Realization result = apiInstance.getRealization(authorization, pid, eid, rid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getRealization");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to which the realization belongs
        String rid = rid_example; // String | id of the realization to get
        try {
            Realization result = apiInstance.getRealization(authorization, pid, eid, rid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getRealization");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment to which the realization belongs
String *rid = rid_example; // id of the realization to get

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

// Get realization data
[apiInstance getRealizationWith:authorization
    pid:pid
    eid:eid
    rid:rid
              completionHandler: ^(Realization output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment to which the realization belongs

var rid = rid_example; // {String} id of the realization to get


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

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

namespace Example
{
    public class getRealizationExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment to which the realization belongs
            var rid = rid_example;  // String | id of the realization to get

            try
            {
                // Get realization data
                Realization result = apiInstance.getRealization(authorization, pid, eid, rid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getRealization: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment to which the realization belongs
$rid = rid_example; // String | id of the realization to get

try {
    $result = $api_instance->getRealization($authorization, $pid, $eid, $rid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getRealization: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment to which the realization belongs
my $rid = rid_example; # String | id of the realization to get

eval { 
    my $result = $api_instance->getRealization(authorization => $authorization, pid => $pid, eid => $eid, rid => $rid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getRealization: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment to which the realization belongs
rid = rid_example # String | id of the realization to get

try: 
    # Get realization data
    api_response = api_instance.get_realization(authorization, pid, eid, rid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getRealization: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id of the experiment
        String eid = eid_example; // String | experiment id of the realizations
        try {
            array['String'] result = apiInstance.getRealizations(authorization, pid, eid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getRealizations");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id of the experiment
        String eid = eid_example; // String | experiment id of the realizations
        try {
            array['String'] result = apiInstance.getRealizations(authorization, pid, eid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getRealizations");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id of the experiment
String *eid = eid_example; // experiment id of the realizations

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

// List an experiments realizations
[apiInstance getRealizationsWith:authorization
    pid:pid
    eid:eid
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id of the experiment

var eid = eid_example; // {String} experiment id of the realizations


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

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

namespace Example
{
    public class getRealizationsExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id of the experiment
            var eid = eid_example;  // String | experiment id of the realizations

            try
            {
                // List an experiments realizations
                array['String'] result = apiInstance.getRealizations(authorization, pid, eid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getRealizations: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id of the experiment
$eid = eid_example; // String | experiment id of the realizations

try {
    $result = $api_instance->getRealizations($authorization, $pid, $eid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getRealizations: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id of the experiment
my $eid = eid_example; # String | experiment id of the realizations

eval { 
    my $result = $api_instance->getRealizations(authorization => $authorization, pid => $pid, eid => $eid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getRealizations: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id of the experiment
eid = eid_example # String | experiment id of the realizations

try: 
    # List an experiments realizations
    api_response = api_instance.get_realizations(authorization, pid, eid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getRealizations: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        try {
            array[Resource] result = apiInstance.getResources(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getResources");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        try {
            array[Resource] result = apiInstance.getResources(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getResources");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format

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

// List resources
[apiInstance getResourcesWith:authorization
              completionHandler: ^(array[Resource] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format


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

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

namespace Example
{
    public class getResourcesExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format

            try
            {
                // List resources
                array[Resource] result = apiInstance.getResources(authorization);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getResources: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format

eval { 
    my $result = $api_instance->getResources(authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getResources: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format

try: 
    # List resources
    api_response = api_instance.get_resources(authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getResources: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to get
        try {
            Site result = apiInstance.getSite(authorization, sid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSite");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to get
        try {
            Site result = apiInstance.getSite(authorization, sid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSite");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *sid = sid_example; // site id to get

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

// Get a sites info
[apiInstance getSiteWith:authorization
    sid:sid
              completionHandler: ^(Site output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var sid = sid_example; // {String} site id to get


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

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

namespace Example
{
    public class getSiteExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var sid = sid_example;  // String | site id to get

            try
            {
                // Get a sites info
                Site result = apiInstance.getSite(authorization, sid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getSite: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$sid = sid_example; // String | site id to get

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $sid = sid_example; # String | site id to get

eval { 
    my $result = $api_instance->getSite(authorization => $authorization, sid => $sid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSite: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
sid = sid_example # String | site id to get

try: 
    # Get a sites info
    api_response = api_instance.get_site(authorization, sid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSite: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        try {
            array[Site] result = apiInstance.getSites(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSites");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        try {
            array[Site] result = apiInstance.getSites(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSites");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format

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

// List sites
[apiInstance getSitesWith:authorization
              completionHandler: ^(array[Site] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format


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

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

namespace Example
{
    public class getSitesExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format

            try
            {
                // List sites
                array[Site] result = apiInstance.getSites(authorization);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getSites: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format

eval { 
    my $result = $api_instance->getSites(authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSites: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format

try: 
    # List sites
    api_response = api_instance.get_sites(authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSites: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String uid = uid_example; // String | user id to get
        try {
            User result = apiInstance.getUser(authorization, uid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String uid = uid_example; // String | user id to get
        try {
            User result = apiInstance.getUser(authorization, uid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUser");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *uid = uid_example; // user id to get

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

// Get a users info
[apiInstance getUserWith:authorization
    uid:uid
              completionHandler: ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var uid = uid_example; // {String} user id to get


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

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

namespace Example
{
    public class getUserExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var uid = uid_example;  // String | user id to get

            try
            {
                // Get a users info
                User result = apiInstance.getUser(authorization, uid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getUser: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$uid = uid_example; // String | user id to get

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $uid = uid_example; # String | user id to get

eval { 
    my $result = $api_instance->getUser(authorization => $authorization, uid => $uid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getUser: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
uid = uid_example # String | user id to get

try: 
    # Get a users info
    api_response = api_instance.get_user(authorization, uid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getUser: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String uid = uid_example; // String | the id of the user
        try {
            array[PublicKey] result = apiInstance.getUserPublicKeys(authorization, uid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUserPublicKeys");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String uid = uid_example; // String | the id of the user
        try {
            array[PublicKey] result = apiInstance.getUserPublicKeys(authorization, uid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUserPublicKeys");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *uid = uid_example; // the id of the user

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

// Get a list of user public keys
[apiInstance getUserPublicKeysWith:authorization
    uid:uid
              completionHandler: ^(array[PublicKey] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var uid = uid_example; // {String} the id of the user


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

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

namespace Example
{
    public class getUserPublicKeysExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var uid = uid_example;  // String | the id of the user

            try
            {
                // Get a list of user public keys
                array[PublicKey] result = apiInstance.getUserPublicKeys(authorization, uid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getUserPublicKeys: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$uid = uid_example; // String | the id of the user

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $uid = uid_example; # String | the id of the user

eval { 
    my $result = $api_instance->getUserPublicKeys(authorization => $authorization, uid => $uid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getUserPublicKeys: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
uid = uid_example # String | the id of the user

try: 
    # Get a list of user public keys
    api_response = api_instance.get_user_public_keys(authorization, uid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getUserPublicKeys: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        try {
            array[User] result = apiInstance.getUsers(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUsers");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        try {
            array[User] result = apiInstance.getUsers(authorization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUsers");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format

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

// List users
[apiInstance getUsersWith:authorization
              completionHandler: ^(array[User] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format


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

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

namespace Example
{
    public class getUsersExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format

            try
            {
                // List users
                array[User] result = apiInstance.getUsers(authorization);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getUsers: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format

eval { 
    my $result = $api_instance->getUsers(authorization => $authorization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getUsers: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format

try: 
    # List users
    api_response = api_instance.get_users(authorization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getUsers: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment in which the xdc is spawned
        String xdcid = xdcid_example; // String | name/id of the xdc
        try {
            'String' result = apiInstance.getXdcToken(authorization, pid, eid, xdcid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getXdcToken");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment in which the xdc is spawned
        String xdcid = xdcid_example; // String | name/id of the xdc
        try {
            'String' result = apiInstance.getXdcToken(authorization, pid, eid, xdcid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getXdcToken");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment in which the xdc is spawned
String *xdcid = xdcid_example; // name/id of the xdc

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

// Request the Jupyter token to unlock the given XDC jupyter instance.
[apiInstance getXdcTokenWith:authorization
    pid:pid
    eid:eid
    xdcid:xdcid
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment in which the xdc is spawned

var xdcid = xdcid_example; // {String} name/id of the xdc


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

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

namespace Example
{
    public class getXdcTokenExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment in which the xdc is spawned
            var xdcid = xdcid_example;  // String | name/id of the xdc

            try
            {
                // Request the Jupyter token to unlock the given XDC jupyter instance.
                'String' result = apiInstance.getXdcToken(authorization, pid, eid, xdcid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getXdcToken: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment in which the xdc is spawned
$xdcid = xdcid_example; // String | name/id of the xdc

try {
    $result = $api_instance->getXdcToken($authorization, $pid, $eid, $xdcid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getXdcToken: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment in which the xdc is spawned
my $xdcid = xdcid_example; # String | name/id of the xdc

eval { 
    my $result = $api_instance->getXdcToken(authorization => $authorization, pid => $pid, eid => $eid, xdcid => $xdcid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getXdcToken: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment in which the xdc is spawned
xdcid = xdcid_example # String | name/id of the xdc

try: 
    # Request the Jupyter token to unlock the given XDC jupyter instance.
    api_response = api_instance.get_xdc_token(authorization, pid, eid, xdcid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getXdcToken: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        try {
            apiInstance.initUser(authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#initUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        try {
            apiInstance.initUser(authorization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#initUser");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format

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

// Initialize a user based on OAuth2 token
[apiInstance initUserWith:authorization
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format


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

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

namespace Example
{
    public class initUserExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format

            try
            {
                // Initialize a user based on OAuth2 token
                apiInstance.initUser(authorization);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.initUser: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format

eval { 
    $api_instance->initUser(authorization => $authorization);
};
if ($@) {
    warn "Exception when calling DefaultApi->initUser: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format

try: 
    # Initialize a user based on OAuth2 token
    api_instance.init_user(authorization)
except ApiException as e:
    print("Exception when calling DefaultApi->initUser: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment
        try {
            array[XdcInfo] result = apiInstance.listXdc(authorization, pid, eid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listXdc");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment
        try {
            array[XdcInfo] result = apiInstance.listXdc(authorization, pid, eid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listXdc");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment

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

// List all experiment development containers in this experiment.
[apiInstance listXdcWith:authorization
    pid:pid
    eid:eid
              completionHandler: ^(array[XdcInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment


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

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

namespace Example
{
    public class listXdcExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment

            try
            {
                // List all experiment development containers in this experiment.
                array[XdcInfo] result = apiInstance.listXdc(authorization, pid, eid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.listXdc: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment

try {
    $result = $api_instance->listXdc($authorization, $pid, $eid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->listXdc: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment

eval { 
    my $result = $api_instance->listXdc(authorization => $authorization, pid => $pid, eid => $eid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->listXdc: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment

try: 
    # List all experiment development containers in this experiment.
    api_response = api_instance.list_xdc(authorization, pid, eid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->listXdc: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String rid = rid_example; // String | realization id
        AddPublicKey key = ; // AddPublicKey | key to add
        try {
            MaterializeAttachResponse result = apiInstance.materializeConnectionAttach(authorization, pid, eid, rid, key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#materializeConnectionAttach");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String rid = rid_example; // String | realization id
        AddPublicKey key = ; // AddPublicKey | key to add
        try {
            MaterializeAttachResponse result = apiInstance.materializeConnectionAttach(authorization, pid, eid, rid, key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#materializeConnectionAttach");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id
String *eid = eid_example; // experiment id
String *rid = rid_example; // realization id
AddPublicKey *key = ; // key to add

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

// Request secure network access to an existing materialization. Give a 
public key and get back connection details.

[apiInstance materializeConnectionAttachWith:authorization
    pid:pid
    eid:eid
    rid:rid
    key:key
              completionHandler: ^(MaterializeAttachResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id

var eid = eid_example; // {String} experiment id

var rid = rid_example; // {String} realization id

var key = ; // {AddPublicKey} key to add


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.materializeConnectionAttach(authorization, pid, eid, rid, key, callback);

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

namespace Example
{
    public class materializeConnectionAttachExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id
            var eid = eid_example;  // String | experiment id
            var rid = rid_example;  // String | realization id
            var key = new AddPublicKey(); // AddPublicKey | key to add

            try
            {
                // Request secure network access to an existing materialization. Give a 
public key and get back connection details.

                MaterializeAttachResponse result = apiInstance.materializeConnectionAttach(authorization, pid, eid, rid, key);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.materializeConnectionAttach: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id
$eid = eid_example; // String | experiment id
$rid = rid_example; // String | realization id
$key = ; // AddPublicKey | key to add

try {
    $result = $api_instance->materializeConnectionAttach($authorization, $pid, $eid, $rid, $key);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->materializeConnectionAttach: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id
my $eid = eid_example; # String | experiment id
my $rid = rid_example; # String | realization id
my $key = WWW::SwaggerClient::Object::AddPublicKey->new(); # AddPublicKey | key to add

eval { 
    my $result = $api_instance->materializeConnectionAttach(authorization => $authorization, pid => $pid, eid => $eid, rid => $rid, key => $key);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->materializeConnectionAttach: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id
eid = eid_example # String | experiment id
rid = rid_example # String | realization id
key =  # AddPublicKey | key to add

try: 
    # Request secure network access to an existing materialization. Give a 
public key and get back connection details.

    api_response = api_instance.materialize_connection_attach(authorization, pid, eid, rid, key)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->materializeConnectionAttach: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String rid = rid_example; // String | realization id
        ConnectionDetachRequest request = ; // ConnectionDetachRequest | key to remove from the connection
        try {
            apiInstance.materializeConnectionDetach(authorization, pid, eid, rid, request);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#materializeConnectionDetach");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | project id
        String eid = eid_example; // String | experiment id
        String rid = rid_example; // String | realization id
        ConnectionDetachRequest request = ; // ConnectionDetachRequest | key to remove from the connection
        try {
            apiInstance.materializeConnectionDetach(authorization, pid, eid, rid, request);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#materializeConnectionDetach");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // project id
String *eid = eid_example; // experiment id
String *rid = rid_example; // realization id
ConnectionDetachRequest *request = ; // key to remove from the connection

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

// Detach from a materialization connection.
[apiInstance materializeConnectionDetachWith:authorization
    pid:pid
    eid:eid
    rid:rid
    request:request
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} project id

var eid = eid_example; // {String} experiment id

var rid = rid_example; // {String} realization id

var request = ; // {ConnectionDetachRequest} key to remove from the connection


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.materializeConnectionDetach(authorization, pid, eid, rid, request, callback);

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

namespace Example
{
    public class materializeConnectionDetachExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | project id
            var eid = eid_example;  // String | experiment id
            var rid = rid_example;  // String | realization id
            var request = new ConnectionDetachRequest(); // ConnectionDetachRequest | key to remove from the connection

            try
            {
                // Detach from a materialization connection.
                apiInstance.materializeConnectionDetach(authorization, pid, eid, rid, request);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.materializeConnectionDetach: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | project id
$eid = eid_example; // String | experiment id
$rid = rid_example; // String | realization id
$request = ; // ConnectionDetachRequest | key to remove from the connection

try {
    $api_instance->materializeConnectionDetach($authorization, $pid, $eid, $rid, $request);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->materializeConnectionDetach: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | project id
my $eid = eid_example; # String | experiment id
my $rid = rid_example; # String | realization id
my $request = WWW::SwaggerClient::Object::ConnectionDetachRequest->new(); # ConnectionDetachRequest | key to remove from the connection

eval { 
    $api_instance->materializeConnectionDetach(authorization => $authorization, pid => $pid, eid => $eid, rid => $rid, request => $request);
};
if ($@) {
    warn "Exception when calling DefaultApi->materializeConnectionDetach: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | project id
eid = eid_example # String | experiment id
rid = rid_example # String | realization id
request =  # ConnectionDetachRequest | key to remove from the connection

try: 
    # Detach from a materialization connection.
    api_instance.materialize_connection_detach(authorization, pid, eid, rid, request)
except ApiException as e:
    print("Exception when calling DefaultApi->materializeConnectionDetach: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        String hash = hash_example; // String | hash of the source to pull
        try {
            XpSource result = apiInstance.pullExperiment(authorization, pid, eid, hash);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#pullExperiment");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        String hash = hash_example; // String | hash of the source to pull
        try {
            XpSource result = apiInstance.pullExperiment(authorization, pid, eid, hash);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#pullExperiment");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment to create
String *hash = hash_example; // hash of the source to pull

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

// Pull a source version by hash
[apiInstance pullExperimentWith:authorization
    pid:pid
    eid:eid
    hash:hash
              completionHandler: ^(XpSource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment to create

var hash = hash_example; // {String} hash of the source to pull


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

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

namespace Example
{
    public class pullExperimentExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment to create
            var hash = hash_example;  // String | hash of the source to pull

            try
            {
                // Pull a source version by hash
                XpSource result = apiInstance.pullExperiment(authorization, pid, eid, hash);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.pullExperiment: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment to create
$hash = hash_example; // String | hash of the source to pull

try {
    $result = $api_instance->pullExperiment($authorization, $pid, $eid, $hash);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->pullExperiment: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment to create
my $hash = hash_example; # String | hash of the source to pull

eval { 
    my $result = $api_instance->pullExperiment(authorization => $authorization, pid => $pid, eid => $eid, hash => $hash);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->pullExperiment: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment to create
hash = hash_example # String | hash of the source to pull

try: 
    # Pull a source version by hash
    api_response = api_instance.pull_experiment(authorization, pid, eid, hash)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->pullExperiment: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        try {
            array['String'] result = apiInstance.pullExperiments(authorization, pid, eid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#pullExperiments");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        try {
            array['String'] result = apiInstance.pullExperiments(authorization, pid, eid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#pullExperiments");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment to create

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

// List all source versions of an experiment
[apiInstance pullExperimentsWith:authorization
    pid:pid
    eid:eid
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment to create


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

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

namespace Example
{
    public class pullExperimentsExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment to create

            try
            {
                // List all source versions of an experiment
                array['String'] result = apiInstance.pullExperiments(authorization, pid, eid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.pullExperiments: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment to create

try {
    $result = $api_instance->pullExperiments($authorization, $pid, $eid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->pullExperiments: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment to create

eval { 
    my $result = $api_instance->pullExperiments(authorization => $authorization, pid => $pid, eid => $eid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->pullExperiments: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment to create

try: 
    # List all source versions of an experiment
    api_response = api_instance.pull_experiments(authorization, pid, eid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->pullExperiments: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        XpPush pushRequest = ; // XpPush | experiment source
        try {
            'String' result = apiInstance.pushExperiment(authorization, pid, eid, pushRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#pushExperiment");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        XpPush pushRequest = ; // XpPush | experiment source
        try {
            'String' result = apiInstance.pushExperiment(authorization, pid, eid, pushRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#pushExperiment");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment to create
XpPush *pushRequest = ; // experiment source

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

// Push a new version of an experiment
[apiInstance pushExperimentWith:authorization
    pid:pid
    eid:eid
    pushRequest:pushRequest
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment to create

var pushRequest = ; // {XpPush} experiment source


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

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

namespace Example
{
    public class pushExperimentExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment to create
            var pushRequest = new XpPush(); // XpPush | experiment source

            try
            {
                // Push a new version of an experiment
                'String' result = apiInstance.pushExperiment(authorization, pid, eid, pushRequest);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.pushExperiment: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment to create
$pushRequest = ; // XpPush | experiment source

try {
    $result = $api_instance->pushExperiment($authorization, $pid, $eid, $pushRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->pushExperiment: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment to create
my $pushRequest = WWW::SwaggerClient::Object::XpPush->new(); # XpPush | experiment source

eval { 
    my $result = $api_instance->pushExperiment(authorization => $authorization, pid => $pid, eid => $eid, pushRequest => $pushRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->pushExperiment: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment to create
pushRequest =  # XpPush | experiment source

try: 
    # Push a new version of an experiment
    api_response = api_instance.push_experiment(authorization, pid, eid, pushRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->pushExperiment: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to create
        Site newSite = ; // Site | Site to add
        try {
            RegisterResponse result = apiInstance.registerSite(authorization, sid, newSite);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#registerSite");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to create
        Site newSite = ; // Site | Site to add
        try {
            RegisterResponse result = apiInstance.registerSite(authorization, sid, newSite);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#registerSite");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *sid = sid_example; // site id to create
Site *newSite = ; // Site to add

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

// Create a new site
[apiInstance registerSiteWith:authorization
    sid:sid
    newSite:newSite
              completionHandler: ^(RegisterResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var sid = sid_example; // {String} site id to create

var newSite = ; // {Site} Site to add


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

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

namespace Example
{
    public class registerSiteExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var sid = sid_example;  // String | site id to create
            var newSite = new Site(); // Site | Site to add

            try
            {
                // Create a new site
                RegisterResponse result = apiInstance.registerSite(authorization, sid, newSite);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.registerSite: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$sid = sid_example; // String | site id to create
$newSite = ; // Site | Site to add

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $sid = sid_example; # String | site id to create
my $newSite = WWW::SwaggerClient::Object::Site->new(); # Site | Site to add

eval { 
    my $result = $api_instance->registerSite(authorization => $authorization, sid => $sid, newSite => $newSite);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->registerSite: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
sid = sid_example # String | site id to create
newSite =  # Site | Site to add

try: 
    # Create a new site
    api_response = api_instance.register_site(authorization, sid, newSite)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->registerSite: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id
        String xid = xid_example; // String | project id to set state for
        PoolProjectState state = ; // PoolProjectState | project state to set
        try {
            apiInstance.setPoolProjectState(authorization, pid, xid, state);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#setPoolProjectState");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id
        String xid = xid_example; // String | project id to set state for
        PoolProjectState state = ; // PoolProjectState | project state to set
        try {
            apiInstance.setPoolProjectState(authorization, pid, xid, state);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#setPoolProjectState");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // pool id
String *xid = xid_example; // project id to set state for
PoolProjectState *state = ; // project state to set

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

// Set project's pool membership state
[apiInstance setPoolProjectStateWith:authorization
    pid:pid
    xid:xid
    state:state
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} pool id

var xid = xid_example; // {String} project id to set state for

var state = ; // {PoolProjectState} project state to set


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setPoolProjectState(authorization, pid, xid, state, callback);

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

namespace Example
{
    public class setPoolProjectStateExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | pool id
            var xid = xid_example;  // String | project id to set state for
            var state = new PoolProjectState(); // PoolProjectState | project state to set

            try
            {
                // Set project's pool membership state
                apiInstance.setPoolProjectState(authorization, pid, xid, state);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.setPoolProjectState: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | pool id
$xid = xid_example; // String | project id to set state for
$state = ; // PoolProjectState | project state to set

try {
    $api_instance->setPoolProjectState($authorization, $pid, $xid, $state);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->setPoolProjectState: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | pool id
my $xid = xid_example; # String | project id to set state for
my $state = WWW::SwaggerClient::Object::PoolProjectState->new(); # PoolProjectState | project state to set

eval { 
    $api_instance->setPoolProjectState(authorization => $authorization, pid => $pid, xid => $xid, state => $state);
};
if ($@) {
    warn "Exception when calling DefaultApi->setPoolProjectState: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | pool id
xid = xid_example # String | project id to set state for
state =  # PoolProjectState | project state to set

try: 
    # Set project's pool membership state
    api_instance.set_pool_project_state(authorization, pid, xid, state)
except ApiException as e:
    print("Exception when calling DefaultApi->setPoolProjectState: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id
        String sid = sid_example; // String | site id to set state for
        PoolSiteState state = ; // PoolSiteState | project state to set
        try {
            apiInstance.setPoolSiteState(authorization, pid, sid, state);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#setPoolSiteState");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | pool id
        String sid = sid_example; // String | site id to set state for
        PoolSiteState state = ; // PoolSiteState | project state to set
        try {
            apiInstance.setPoolSiteState(authorization, pid, sid, state);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#setPoolSiteState");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // pool id
String *sid = sid_example; // site id to set state for
PoolSiteState *state = ; // project state to set

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

// Set site's pool membership state
[apiInstance setPoolSiteStateWith:authorization
    pid:pid
    sid:sid
    state:state
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} pool id

var sid = sid_example; // {String} site id to set state for

var state = ; // {PoolSiteState} project state to set


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setPoolSiteState(authorization, pid, sid, state, callback);

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

namespace Example
{
    public class setPoolSiteStateExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | pool id
            var sid = sid_example;  // String | site id to set state for
            var state = new PoolSiteState(); // PoolSiteState | project state to set

            try
            {
                // Set site's pool membership state
                apiInstance.setPoolSiteState(authorization, pid, sid, state);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.setPoolSiteState: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | pool id
$sid = sid_example; // String | site id to set state for
$state = ; // PoolSiteState | project state to set

try {
    $api_instance->setPoolSiteState($authorization, $pid, $sid, $state);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->setPoolSiteState: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | pool id
my $sid = sid_example; # String | site id to set state for
my $state = WWW::SwaggerClient::Object::PoolSiteState->new(); # PoolSiteState | project state to set

eval { 
    $api_instance->setPoolSiteState(authorization => $authorization, pid => $pid, sid => $sid, state => $state);
};
if ($@) {
    warn "Exception when calling DefaultApi->setPoolSiteState: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | pool id
sid = sid_example # String | site id to set state for
state =  # PoolSiteState | project state to set

try: 
    # Set site's pool membership state
    api_instance.set_pool_site_state(authorization, pid, sid, state)
except ApiException as e:
    print("Exception when calling DefaultApi->setPoolSiteState: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to update
        SiteCert siteCert = ; // SiteCert | TLS certificate
        try {
            apiInstance.setSiteCert(authorization, sid, siteCert);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#setSiteCert");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to update
        SiteCert siteCert = ; // SiteCert | TLS certificate
        try {
            apiInstance.setSiteCert(authorization, sid, siteCert);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#setSiteCert");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *sid = sid_example; // site id to update
SiteCert *siteCert = ; // TLS certificate (optional)

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

// Set site commander certificate
[apiInstance setSiteCertWith:authorization
    sid:sid
    siteCert:siteCert
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var sid = sid_example; // {String} site id to update

var opts = { 
  'siteCert':  // {SiteCert} TLS certificate
};

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

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

namespace Example
{
    public class setSiteCertExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var sid = sid_example;  // String | site id to update
            var siteCert = new SiteCert(); // SiteCert | TLS certificate (optional) 

            try
            {
                // Set site commander certificate
                apiInstance.setSiteCert(authorization, sid, siteCert);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.setSiteCert: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$sid = sid_example; // String | site id to update
$siteCert = ; // SiteCert | TLS certificate

try {
    $api_instance->setSiteCert($authorization, $sid, $siteCert);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->setSiteCert: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $sid = sid_example; # String | site id to update
my $siteCert = WWW::SwaggerClient::Object::SiteCert->new(); # SiteCert | TLS certificate

eval { 
    $api_instance->setSiteCert(authorization => $authorization, sid => $sid, siteCert => $siteCert);
};
if ($@) {
    warn "Exception when calling DefaultApi->setSiteCert: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
sid = sid_example # String | site id to update
siteCert =  # SiteCert | TLS certificate (optional)

try: 
    # Set site commander certificate
    api_instance.set_site_cert(authorization, sid, siteCert=siteCert)
except ApiException as e:
    print("Exception when calling DefaultApi->setSiteCert: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to update
        WgdSiteConfig wgdConfig = ; // WgdSiteConfig | TLS certificate
        try {
            apiInstance.setSiteWgdConfig(authorization, sid, wgdConfig);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#setSiteWgdConfig");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to update
        WgdSiteConfig wgdConfig = ; // WgdSiteConfig | TLS certificate
        try {
            apiInstance.setSiteWgdConfig(authorization, sid, wgdConfig);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#setSiteWgdConfig");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *sid = sid_example; // site id to update
WgdSiteConfig *wgdConfig = ; // TLS certificate (optional)

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

// Set site wireguard daemon certificate and address
[apiInstance setSiteWgdConfigWith:authorization
    sid:sid
    wgdConfig:wgdConfig
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var sid = sid_example; // {String} site id to update

var opts = { 
  'wgdConfig':  // {WgdSiteConfig} TLS certificate
};

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

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

namespace Example
{
    public class setSiteWgdConfigExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var sid = sid_example;  // String | site id to update
            var wgdConfig = new WgdSiteConfig(); // WgdSiteConfig | TLS certificate (optional) 

            try
            {
                // Set site wireguard daemon certificate and address
                apiInstance.setSiteWgdConfig(authorization, sid, wgdConfig);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.setSiteWgdConfig: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$sid = sid_example; // String | site id to update
$wgdConfig = ; // WgdSiteConfig | TLS certificate

try {
    $api_instance->setSiteWgdConfig($authorization, $sid, $wgdConfig);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->setSiteWgdConfig: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $sid = sid_example; # String | site id to update
my $wgdConfig = WWW::SwaggerClient::Object::WgdSiteConfig->new(); # WgdSiteConfig | TLS certificate

eval { 
    $api_instance->setSiteWgdConfig(authorization => $authorization, sid => $sid, wgdConfig => $wgdConfig);
};
if ($@) {
    warn "Exception when calling DefaultApi->setSiteWgdConfig: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
sid = sid_example # String | site id to update
wgdConfig =  # WgdSiteConfig | TLS certificate (optional)

try: 
    # Set site wireguard daemon certificate and address
    api_instance.set_site_wgd_config(authorization, sid, wgdConfig=wgdConfig)
except ApiException as e:
    print("Exception when calling DefaultApi->setSiteWgdConfig: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment in which the xdc is spawned
        String xdcid = xdcid_example; // String | name/id of the xdc to spawn
        try {
            apiInstance.spawnXdc(authorization, pid, eid, xdcid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#spawnXdc");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment in which the xdc is spawned
        String xdcid = xdcid_example; // String | name/id of the xdc to spawn
        try {
            apiInstance.spawnXdc(authorization, pid, eid, xdcid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#spawnXdc");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment in which the xdc is spawned
String *xdcid = xdcid_example; // name/id of the xdc to spawn

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

// Spawn a new XDC for the given experiment.
[apiInstance spawnXdcWith:authorization
    pid:pid
    eid:eid
    xdcid:xdcid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment in which the xdc is spawned

var xdcid = xdcid_example; // {String} name/id of the xdc to spawn


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.spawnXdc(authorization, pid, eid, xdcid, callback);

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

namespace Example
{
    public class spawnXdcExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment in which the xdc is spawned
            var xdcid = xdcid_example;  // String | name/id of the xdc to spawn

            try
            {
                // Spawn a new XDC for the given experiment.
                apiInstance.spawnXdc(authorization, pid, eid, xdcid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.spawnXdc: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment in which the xdc is spawned
$xdcid = xdcid_example; // String | name/id of the xdc to spawn

try {
    $api_instance->spawnXdc($authorization, $pid, $eid, $xdcid);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->spawnXdc: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment in which the xdc is spawned
my $xdcid = xdcid_example; # String | name/id of the xdc to spawn

eval { 
    $api_instance->spawnXdc(authorization => $authorization, pid => $pid, eid => $eid, xdcid => $xdcid);
};
if ($@) {
    warn "Exception when calling DefaultApi->spawnXdc: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment in which the xdc is spawned
xdcid = xdcid_example # String | name/id of the xdc to spawn

try: 
    # Spawn a new XDC for the given experiment.
    api_instance.spawn_xdc(authorization, pid, eid, xdcid)
except ApiException as e:
    print("Exception when calling DefaultApi->spawnXdc: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to delete
        try {
            RegisterResponse result = apiInstance.unregisterSite(authorization, sid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#unregisterSite");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String sid = sid_example; // String | site id to delete
        try {
            RegisterResponse result = apiInstance.unregisterSite(authorization, sid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#unregisterSite");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *sid = sid_example; // site id to delete

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

// Deletes a site
[apiInstance unregisterSiteWith:authorization
    sid:sid
              completionHandler: ^(RegisterResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var sid = sid_example; // {String} site id to delete


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

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

namespace Example
{
    public class unregisterSiteExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var sid = sid_example;  // String | site id to delete

            try
            {
                // Deletes a site
                RegisterResponse result = apiInstance.unregisterSite(authorization, sid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.unregisterSite: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$sid = sid_example; // String | site id to delete

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $sid = sid_example; # String | site id to delete

eval { 
    my $result = $api_instance->unregisterSite(authorization => $authorization, sid => $sid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->unregisterSite: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
sid = sid_example # String | site id to delete

try: 
    # Deletes a site
    api_response = api_instance.unregister_site(authorization, sid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->unregisterSite: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        Experiment experimentUpdate = ; // Experiment | Experiment to update
        try {
            apiInstance.updateExperiment(authorization, pid, eid, experimentUpdate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateExperiment");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String authorization = authorization_example; // String | API access authorization in JWT access token format
        String pid = pid_example; // String | id of the project to which the experiment belongs
        String eid = eid_example; // String | id of the experiment to create
        Experiment experimentUpdate = ; // Experiment | Experiment to update
        try {
            apiInstance.updateExperiment(authorization, pid, eid, experimentUpdate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateExperiment");
            e.printStackTrace();
        }
    }
}

String *authorization = authorization_example; // API access authorization in JWT access token format
String *pid = pid_example; // id of the project to which the experiment belongs
String *eid = eid_example; // id of the experiment to create
Experiment *experimentUpdate = ; // Experiment to update (optional)

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

// Update an experiment
[apiInstance updateExperimentWith:authorization
    pid:pid
    eid:eid
    experimentUpdate:experimentUpdate
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var Mergetb = require('mergetb');

var api = new Mergetb.DefaultApi()

var authorization = authorization_example; // {String} API access authorization in JWT access token format

var pid = pid_example; // {String} id of the project to which the experiment belongs

var eid = eid_example; // {String} id of the experiment to create

var opts = { 
  'experimentUpdate':  // {Experiment} Experiment to update
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateExperiment(authorization, pid, eid, opts, callback);

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

namespace Example
{
    public class updateExperimentExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var authorization = authorization_example;  // String | API access authorization in JWT access token format
            var pid = pid_example;  // String | id of the project to which the experiment belongs
            var eid = eid_example;  // String | id of the experiment to create
            var experimentUpdate = new Experiment(); // Experiment | Experiment to update (optional) 

            try
            {
                // Update an experiment
                apiInstance.updateExperiment(authorization, pid, eid, experimentUpdate);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.updateExperiment: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$authorization = authorization_example; // String | API access authorization in JWT access token format
$pid = pid_example; // String | id of the project to which the experiment belongs
$eid = eid_example; // String | id of the experiment to create
$experimentUpdate = ; // Experiment | Experiment to update

try {
    $api_instance->updateExperiment($authorization, $pid, $eid, $experimentUpdate);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateExperiment: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $authorization = authorization_example; # String | API access authorization in JWT access token format
my $pid = pid_example; # String | id of the project to which the experiment belongs
my $eid = eid_example; # String | id of the experiment to create
my $experimentUpdate = WWW::SwaggerClient::Object::Experiment->new(); # Experiment | Experiment to update

eval { 
    $api_instance->updateExperiment(authorization => $authorization, pid => $pid, eid => $eid, experimentUpdate => $experimentUpdate);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateExperiment: $@\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.DefaultApi()
authorization = authorization_example # String | API access authorization in JWT access token format
pid = pid_example # String | id of the project to which the experiment belongs
eid = eid_example # String | id of the experiment to create
experimentUpdate =  # Experiment | Experiment to update (optional)

try: 
    # Update an experiment
    api_instance.update_experiment(authorization, pid, eid, experimentUpdate=experimentUpdate)
except ApiException as e:
    print("Exception when calling DefaultApi->updateExperiment: %s\n" % e)