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)