Mediator

/api

Returns the API as OpenAPI 3 specification.

Usage and SDK Samples

curl -X GET\
 -H "Accept: application/json"\
 "http://localhost/api"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        
        try {
            Object result = apiInstance.apiGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#apiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

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



// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];

[apiInstance apiGetWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class apiGetExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();

            try {
                Object result = apiInstance.apiGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.apiGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()

try: 
    api_response = api_instance.api_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MediatorApi->apiGet: %s\n" % e)

extern crate MediatorApi;

pub fn main() {

    let mut context = MediatorApi::Context::default();
    let result = client.apiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

/backups

Returns all backups grouped by volume.

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
 -H "Accept: application/json"\
 "http://localhost/backups"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        
        try {
            Object result = apiInstance.backupsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#backupsGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];

[apiInstance backupsGetWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.backupsGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class backupsGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();

            try {
                Object result = apiInstance.backupsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.backupsGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();

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

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()

try: 
    api_response = api_instance.backups_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MediatorApi->backupsGet: %s\n" % e)

extern crate MediatorApi;

pub fn main() {

    let mut context = MediatorApi::Context::default();
    let result = client.backupsGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

/dumpApplicationState

Writes an application state dump in the working directory

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
 -H "Accept: application/json"\
 "http://localhost/dumpApplicationState"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        
        try {
            Object result = apiInstance.dumpApplicationStatePost();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#dumpApplicationStatePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];

[apiInstance dumpApplicationStatePostWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.dumpApplicationStatePost(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dumpApplicationStatePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();

            try {
                Object result = apiInstance.dumpApplicationStatePost();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.dumpApplicationStatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();

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

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()

try: 
    api_response = api_instance.dump_application_state_post()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MediatorApi->dumpApplicationStatePost: %s\n" % e)

extern crate MediatorApi;

pub fn main() {

    let mut context = MediatorApi::Context::default();
    let result = client.dumpApplicationStatePost(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

/info

Returns basic server information.

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
 -H "Accept: application/json"\
 "http://localhost/info"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        
        try {
            Object result = apiInstance.infoGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#infoGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];

[apiInstance infoGetWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.infoGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class infoGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();

            try {
                Object result = apiInstance.infoGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.infoGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();

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

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()

try: 
    api_response = api_instance.info_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MediatorApi->infoGet: %s\n" % e)

extern crate MediatorApi;

pub fn main() {

    let mut context = MediatorApi::Context::default();
    let result = client.infoGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

/log

Downloads the server log file.

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
 "http://localhost/log"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        
        try {
            apiInstance.logGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#logGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];

[apiInstance logGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.logGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class logGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();

            try {
                apiInstance.logGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.logGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();

eval { 
    $api_instance->logGet();
};
if ($@) {
    warn "Exception when calling MediatorApi->logGet: $@\n";
}

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()

try: 
    api_instance.log_get()
except ApiException as e:
    print("Exception when calling MediatorApi->logGet: %s\n" % e)

extern crate MediatorApi;

pub fn main() {

    let mut context = MediatorApi::Context::default();
    let result = client.logGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

/oauth/redirect

Handles an OAuth redirect

Usage and SDK Samples

curl -X POST\
 "http://localhost/oauth/redirect"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        
        try {
            apiInstance.oauthRedirectPost();
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#oauthRedirectPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

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



// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];

[apiInstance oauthRedirectPostWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.oauthRedirectPost(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class oauthRedirectPostExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();

            try {
                apiInstance.oauthRedirectPost();
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.oauthRedirectPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();

eval { 
    $api_instance->oauthRedirectPost();
};
if ($@) {
    warn "Exception when calling MediatorApi->oauthRedirectPost: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()

try: 
    api_instance.oauth_redirect_post()
except ApiException as e:
    print("Exception when calling MediatorApi->oauthRedirectPost: %s\n" % e)

extern crate MediatorApi;

pub fn main() {

    let mut context = MediatorApi::Context::default();
    let result = client.oauthRedirectPost(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

the static file path for the server administration frontend

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
 "http://localhost/"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        
        try {
            apiInstance.rootGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#rootGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];

[apiInstance rootGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.rootGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class rootGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();

            try {
                apiInstance.rootGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.rootGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();

eval { 
    $api_instance->rootGet();
};
if ($@) {
    warn "Exception when calling MediatorApi->rootGet: $@\n";
}

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()

try: 
    api_instance.root_get()
except ApiException as e:
    print("Exception when calling MediatorApi->rootGet: %s\n" % e)

extern crate MediatorApi;

pub fn main() {

    let mut context = MediatorApi::Context::default();
    let result = client.rootGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

/volumes

Returns all volumes.

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
 -H "Accept: application/json"\
 "http://localhost/volumes"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        
        try {
            Object result = apiInstance.volumesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];

[apiInstance volumesGetWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.volumesGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class volumesGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();

            try {
                Object result = apiInstance.volumesGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();

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

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()

try: 
    api_response = api_instance.volumes_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MediatorApi->volumesGet: %s\n" % e)

extern crate MediatorApi;

pub fn main() {

    let mut context = MediatorApi::Context::default();
    let result = client.volumesGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

/volumes

Uploads the volume that is attached to the request. The name of the uploaded zip file is used as volumeID.

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
 "http://localhost/volumes"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        
        try {
            apiInstance.volumesPost();
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];

[apiInstance volumesPostWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.volumesPost(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class volumesPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();

            try {
                apiInstance.volumesPost();
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesPost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();

eval { 
    $api_instance->volumesPost();
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesPost: $@\n";
}

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()

try: 
    api_instance.volumes_post()
except ApiException as e:
    print("Exception when calling MediatorApi->volumesPost: %s\n" % e)

extern crate MediatorApi;

pub fn main() {

    let mut context = MediatorApi::Context::default();
    let result = client.volumesPost(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

/volumes/{volumeID}/backups

Returns all backups for the specified volume.

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
 -H "Accept: application/json"\
 "http://localhost/volumes/{volumeID}/backups"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        String volumeID = volumeID_example; // String | the volume name
        
        try {
            Object result = apiInstance.volumesVolumeIDBackupsGet(volumeID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDBackupsGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

public class MediatorApiExample {
    public static void main(String[] args) {
        MediatorApi apiInstance = new MediatorApi();
        String volumeID = volumeID_example; // String | the volume name
        
        try {
            Object result = apiInstance.volumesVolumeIDBackupsGet(volumeID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDBackupsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];
String *volumeID = volumeID_example; // the volume name (default to null)

[apiInstance volumesVolumeIDBackupsGetWith:volumeID
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var volumeID = volumeID_example; // {String} the volume name

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class volumesVolumeIDBackupsGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();
            var volumeID = volumeID_example;  // String | the volume name (default to null)

            try {
                Object result = apiInstance.volumesVolumeIDBackupsGet(volumeID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDBackupsGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();
$volumeID = volumeID_example; // String | the volume name

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();
my $volumeID = volumeID_example; # String | the volume name

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

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()
volumeID = volumeID_example # String | the volume name (default to null)

try: 
    api_response = api_instance.volumes_volume_id_backups_get(volumeID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MediatorApi->volumesVolumeIDBackupsGet: %s\n" % e)

extern crate MediatorApi;

pub fn main() {
    let volumeID = volumeID_example; // String

    let mut context = MediatorApi::Context::default();
    let result = client.volumesVolumeIDBackupsGet(volumeID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String the volume name Required

Responses

Schema

/volumes/{volumeID}/backups/{version}

Deletes the backup with the given version for the specified volume.

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Basic [[basicHash]]"\
 "http://localhost/volumes/{volumeID}/backups/{version}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        String version = version_example; // String | the backup version
        String volumeID = volumeID_example; // String | the volume name
        
        try {
            apiInstance.volumesVolumeIDBackupsVersionDelete(version, volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDBackupsVersionDelete");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

public class MediatorApiExample {
    public static void main(String[] args) {
        MediatorApi apiInstance = new MediatorApi();
        String version = version_example; // String | the backup version
        String volumeID = volumeID_example; // String | the volume name
        
        try {
            apiInstance.volumesVolumeIDBackupsVersionDelete(version, volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDBackupsVersionDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];
String *version = version_example; // the backup version (default to null)
String *volumeID = volumeID_example; // the volume name (default to null)

[apiInstance volumesVolumeIDBackupsVersionDeleteWith:version
    volumeID:volumeID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var version = version_example; // {String} the backup version
var volumeID = volumeID_example; // {String} the volume name

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class volumesVolumeIDBackupsVersionDeleteExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();
            var version = version_example;  // String | the backup version (default to null)
            var volumeID = volumeID_example;  // String | the volume name (default to null)

            try {
                apiInstance.volumesVolumeIDBackupsVersionDelete(version, volumeID);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDBackupsVersionDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();
$version = version_example; // String | the backup version
$volumeID = volumeID_example; // String | the volume name

try {
    $api_instance->volumesVolumeIDBackupsVersionDelete($version, $volumeID);
} catch (Exception $e) {
    echo 'Exception when calling MediatorApi->volumesVolumeIDBackupsVersionDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();
my $version = version_example; # String | the backup version
my $volumeID = volumeID_example; # String | the volume name

eval { 
    $api_instance->volumesVolumeIDBackupsVersionDelete(version => $version, volumeID => $volumeID);
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesVolumeIDBackupsVersionDelete: $@\n";
}

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()
version = version_example # String | the backup version (default to null)
volumeID = volumeID_example # String | the volume name (default to null)

try: 
    api_instance.volumes_volume_id_backups_version_delete(version, volumeID)
except ApiException as e:
    print("Exception when calling MediatorApi->volumesVolumeIDBackupsVersionDelete: %s\n" % e)

extern crate MediatorApi;

pub fn main() {
    let version = version_example; // String
    let volumeID = volumeID_example; // String

    let mut context = MediatorApi::Context::default();
    let result = client.volumesVolumeIDBackupsVersionDelete(version, volumeID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
version*	String the backup version Required
volumeID*	String the volume name Required

Responses

/volumes/{volumeID}/backups/{version}

Restores the backup with the given version for the specified volume.

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
 "http://localhost/volumes/{volumeID}/backups/{version}?targetID="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        String version = version_example; // String | the backup version
        String volumeID = volumeID_example; // String | the volume name
        String targetID = targetID_example; // String | the name for the restored volume
        
        try {
            apiInstance.volumesVolumeIDBackupsVersionPost(version, volumeID, targetID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDBackupsVersionPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

public class MediatorApiExample {
    public static void main(String[] args) {
        MediatorApi apiInstance = new MediatorApi();
        String version = version_example; // String | the backup version
        String volumeID = volumeID_example; // String | the volume name
        String targetID = targetID_example; // String | the name for the restored volume
        
        try {
            apiInstance.volumesVolumeIDBackupsVersionPost(version, volumeID, targetID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDBackupsVersionPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];
String *version = version_example; // the backup version (default to null)
String *volumeID = volumeID_example; // the volume name (default to null)
String *targetID = targetID_example; // the name for the restored volume (optional) (default to null)

[apiInstance volumesVolumeIDBackupsVersionPostWith:version
    volumeID:volumeID
    targetID:targetID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var version = version_example; // {String} the backup version
var volumeID = volumeID_example; // {String} the volume name
var opts = {
  'targetID': targetID_example // {String} the name for the restored volume
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class volumesVolumeIDBackupsVersionPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();
            var version = version_example;  // String | the backup version (default to null)
            var volumeID = volumeID_example;  // String | the volume name (default to null)
            var targetID = targetID_example;  // String | the name for the restored volume (optional)  (default to null)

            try {
                apiInstance.volumesVolumeIDBackupsVersionPost(version, volumeID, targetID);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDBackupsVersionPost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();
$version = version_example; // String | the backup version
$volumeID = volumeID_example; // String | the volume name
$targetID = targetID_example; // String | the name for the restored volume

try {
    $api_instance->volumesVolumeIDBackupsVersionPost($version, $volumeID, $targetID);
} catch (Exception $e) {
    echo 'Exception when calling MediatorApi->volumesVolumeIDBackupsVersionPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();
my $version = version_example; # String | the backup version
my $volumeID = volumeID_example; # String | the volume name
my $targetID = targetID_example; # String | the name for the restored volume

eval { 
    $api_instance->volumesVolumeIDBackupsVersionPost(version => $version, volumeID => $volumeID, targetID => $targetID);
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesVolumeIDBackupsVersionPost: $@\n";
}

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()
version = version_example # String | the backup version (default to null)
volumeID = volumeID_example # String | the volume name (default to null)
targetID = targetID_example # String | the name for the restored volume (optional) (default to null)

try: 
    api_instance.volumes_volume_id_backups_version_post(version, volumeID, targetID=targetID)
except ApiException as e:
    print("Exception when calling MediatorApi->volumesVolumeIDBackupsVersionPost: %s\n" % e)

extern crate MediatorApi;

pub fn main() {
    let version = version_example; // String
    let volumeID = volumeID_example; // String
    let targetID = targetID_example; // String

    let mut context = MediatorApi::Context::default();
    let result = client.volumesVolumeIDBackupsVersionPost(version, volumeID, targetID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
version*	String the backup version Required
volumeID*	String the volume name Required

Query parameters

Name	Description
targetID	String the name for the restored volume

Responses

/volumes/{volumeID}

Deletes the specified volume. Creates a backup before deleting by default.

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Basic [[basicHash]]"\
 "http://localhost/volumes/{volumeID}?backup="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        String volumeID = volumeID_example; // String | the volume name
        Boolean backup = true; // Boolean | set to "false" if no backup should be created before deleting
        
        try {
            apiInstance.volumesVolumeIDDelete(volumeID, backup);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDDelete");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

public class MediatorApiExample {
    public static void main(String[] args) {
        MediatorApi apiInstance = new MediatorApi();
        String volumeID = volumeID_example; // String | the volume name
        Boolean backup = true; // Boolean | set to "false" if no backup should be created before deleting
        
        try {
            apiInstance.volumesVolumeIDDelete(volumeID, backup);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];
String *volumeID = volumeID_example; // the volume name (default to null)
Boolean *backup = true; // set to "false" if no backup should be created before deleting (optional) (default to null)

[apiInstance volumesVolumeIDDeleteWith:volumeID
    backup:backup
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var volumeID = volumeID_example; // {String} the volume name
var opts = {
  'backup': true // {Boolean} set to "false" if no backup should be created before deleting
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class volumesVolumeIDDeleteExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();
            var volumeID = volumeID_example;  // String | the volume name (default to null)
            var backup = true;  // Boolean | set to "false" if no backup should be created before deleting (optional)  (default to null)

            try {
                apiInstance.volumesVolumeIDDelete(volumeID, backup);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();
$volumeID = volumeID_example; // String | the volume name
$backup = true; // Boolean | set to "false" if no backup should be created before deleting

try {
    $api_instance->volumesVolumeIDDelete($volumeID, $backup);
} catch (Exception $e) {
    echo 'Exception when calling MediatorApi->volumesVolumeIDDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();
my $volumeID = volumeID_example; # String | the volume name
my $backup = true; # Boolean | set to "false" if no backup should be created before deleting

eval { 
    $api_instance->volumesVolumeIDDelete(volumeID => $volumeID, backup => $backup);
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesVolumeIDDelete: $@\n";
}

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()
volumeID = volumeID_example # String | the volume name (default to null)
backup = true # Boolean | set to "false" if no backup should be created before deleting (optional) (default to null)

try: 
    api_instance.volumes_volume_id_delete(volumeID, backup=backup)
except ApiException as e:
    print("Exception when calling MediatorApi->volumesVolumeIDDelete: %s\n" % e)

extern crate MediatorApi;

pub fn main() {
    let volumeID = volumeID_example; // String
    let backup = true; // Boolean

    let mut context = MediatorApi::Context::default();
    let result = client.volumesVolumeIDDelete(volumeID, backup, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String the volume name Required

Query parameters

Name	Description
backup	Boolean set to "false" if no backup should be created before deleting

Responses

/volumes/{volumeID}/garbageCollection

Returns the status of the garbage collection for the specified volume

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
 "http://localhost/volumes/{volumeID}/garbageCollection"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        String volumeID = volumeID_example; // String | the volume name
        
        try {
            apiInstance.volumesVolumeIDGarbageCollectionGet(volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDGarbageCollectionGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

public class MediatorApiExample {
    public static void main(String[] args) {
        MediatorApi apiInstance = new MediatorApi();
        String volumeID = volumeID_example; // String | the volume name
        
        try {
            apiInstance.volumesVolumeIDGarbageCollectionGet(volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDGarbageCollectionGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];
String *volumeID = volumeID_example; // the volume name (default to null)

[apiInstance volumesVolumeIDGarbageCollectionGetWith:volumeID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var volumeID = volumeID_example; // {String} the volume name

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class volumesVolumeIDGarbageCollectionGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();
            var volumeID = volumeID_example;  // String | the volume name (default to null)

            try {
                apiInstance.volumesVolumeIDGarbageCollectionGet(volumeID);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDGarbageCollectionGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();
$volumeID = volumeID_example; // String | the volume name

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();
my $volumeID = volumeID_example; # String | the volume name

eval { 
    $api_instance->volumesVolumeIDGarbageCollectionGet(volumeID => $volumeID);
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesVolumeIDGarbageCollectionGet: $@\n";
}

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()
volumeID = volumeID_example # String | the volume name (default to null)

try: 
    api_instance.volumes_volume_id_garbage_collection_get(volumeID)
except ApiException as e:
    print("Exception when calling MediatorApi->volumesVolumeIDGarbageCollectionGet: %s\n" % e)

extern crate MediatorApi;

pub fn main() {
    let volumeID = volumeID_example; // String

    let mut context = MediatorApi::Context::default();
    let result = client.volumesVolumeIDGarbageCollectionGet(volumeID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String the volume name Required

Responses

/volumes/{volumeID}/garbageCollection

Manages the garbage collection for the specified volume

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
 "http://localhost/volumes/{volumeID}/garbageCollection?action="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        String action = action_example; // String | * `pause` - Pauses the garbageCollection ( if active ) for the specified volume.
* `start` - Starts / resumes the garbageCollection for the specified volume.
* `stop` - Stops the garbageCollection ( if active ) for the specified volume.
        String volumeID = volumeID_example; // String | the volume name
        
        try {
            apiInstance.volumesVolumeIDGarbageCollectionPost(action, volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDGarbageCollectionPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

public class MediatorApiExample {
    public static void main(String[] args) {
        MediatorApi apiInstance = new MediatorApi();
        String action = action_example; // String | * `pause` - Pauses the garbageCollection ( if active ) for the specified volume.
* `start` - Starts / resumes the garbageCollection for the specified volume.
* `stop` - Stops the garbageCollection ( if active ) for the specified volume.
        String volumeID = volumeID_example; // String | the volume name
        
        try {
            apiInstance.volumesVolumeIDGarbageCollectionPost(action, volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDGarbageCollectionPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];
String *action = action_example; // * `pause` - Pauses the garbageCollection ( if active ) for the specified volume.
* `start` - Starts / resumes the garbageCollection for the specified volume.
* `stop` - Stops the garbageCollection ( if active ) for the specified volume. (default to null)
String *volumeID = volumeID_example; // the volume name (default to null)

[apiInstance volumesVolumeIDGarbageCollectionPostWith:action
    volumeID:volumeID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var action = action_example; // {String} * `pause` - Pauses the garbageCollection ( if active ) for the specified volume.
* `start` - Starts / resumes the garbageCollection for the specified volume.
* `stop` - Stops the garbageCollection ( if active ) for the specified volume.
var volumeID = volumeID_example; // {String} the volume name

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class volumesVolumeIDGarbageCollectionPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();
            var action = action_example;  // String | * `pause` - Pauses the garbageCollection ( if active ) for the specified volume.
* `start` - Starts / resumes the garbageCollection for the specified volume.
* `stop` - Stops the garbageCollection ( if active ) for the specified volume. (default to null)
            var volumeID = volumeID_example;  // String | the volume name (default to null)

            try {
                apiInstance.volumesVolumeIDGarbageCollectionPost(action, volumeID);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDGarbageCollectionPost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();
$action = action_example; // String | * `pause` - Pauses the garbageCollection ( if active ) for the specified volume.
* `start` - Starts / resumes the garbageCollection for the specified volume.
* `stop` - Stops the garbageCollection ( if active ) for the specified volume.
$volumeID = volumeID_example; // String | the volume name

try {
    $api_instance->volumesVolumeIDGarbageCollectionPost($action, $volumeID);
} catch (Exception $e) {
    echo 'Exception when calling MediatorApi->volumesVolumeIDGarbageCollectionPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();
my $action = action_example; # String | * `pause` - Pauses the garbageCollection ( if active ) for the specified volume.
* `start` - Starts / resumes the garbageCollection for the specified volume.
* `stop` - Stops the garbageCollection ( if active ) for the specified volume.
my $volumeID = volumeID_example; # String | the volume name

eval { 
    $api_instance->volumesVolumeIDGarbageCollectionPost(action => $action, volumeID => $volumeID);
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesVolumeIDGarbageCollectionPost: $@\n";
}

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()
action = action_example # String | * `pause` - Pauses the garbageCollection ( if active ) for the specified volume.
* `start` - Starts / resumes the garbageCollection for the specified volume.
* `stop` - Stops the garbageCollection ( if active ) for the specified volume. (default to null)
volumeID = volumeID_example # String | the volume name (default to null)

try: 
    api_instance.volumes_volume_id_garbage_collection_post(action, volumeID)
except ApiException as e:
    print("Exception when calling MediatorApi->volumesVolumeIDGarbageCollectionPost: %s\n" % e)

extern crate MediatorApi;

pub fn main() {
    let action = action_example; // String
    let volumeID = volumeID_example; // String

    let mut context = MediatorApi::Context::default();
    let result = client.volumesVolumeIDGarbageCollectionPost(action, volumeID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String the volume name Required

Query parameters

Name	Description
action*	String * `pause` - Pauses the garbageCollection ( if active ) for the specified volume. * `start` - Starts / resumes the garbageCollection for the specified volume. * `stop` - Stops the garbageCollection ( if active ) for the specified volume. Required

Responses

/volumes/{volumeID}

Downloads the specified volume.

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
 "http://localhost/volumes/{volumeID}?targetVolumeID="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        String volumeID = volumeID_example; // String | the volume name
        String targetVolumeID = targetVolumeID_example; // String | The name of the downloaded volume. If not specified then it is equal to volumeID 
        
        try {
            apiInstance.volumesVolumeIDGet(volumeID, targetVolumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

public class MediatorApiExample {
    public static void main(String[] args) {
        MediatorApi apiInstance = new MediatorApi();
        String volumeID = volumeID_example; // String | the volume name
        String targetVolumeID = targetVolumeID_example; // String | The name of the downloaded volume. If not specified then it is equal to volumeID 
        
        try {
            apiInstance.volumesVolumeIDGet(volumeID, targetVolumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];
String *volumeID = volumeID_example; // the volume name (default to null)
String *targetVolumeID = targetVolumeID_example; // The name of the downloaded volume. If not specified then it is equal to volumeID  (optional) (default to null)

[apiInstance volumesVolumeIDGetWith:volumeID
    targetVolumeID:targetVolumeID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var volumeID = volumeID_example; // {String} the volume name
var opts = {
  'targetVolumeID': targetVolumeID_example // {String} The name of the downloaded volume. If not specified then it is equal to volumeID 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class volumesVolumeIDGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();
            var volumeID = volumeID_example;  // String | the volume name (default to null)
            var targetVolumeID = targetVolumeID_example;  // String | The name of the downloaded volume. If not specified then it is equal to volumeID  (optional)  (default to null)

            try {
                apiInstance.volumesVolumeIDGet(volumeID, targetVolumeID);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();
$volumeID = volumeID_example; // String | the volume name
$targetVolumeID = targetVolumeID_example; // String | The name of the downloaded volume. If not specified then it is equal to volumeID 

try {
    $api_instance->volumesVolumeIDGet($volumeID, $targetVolumeID);
} catch (Exception $e) {
    echo 'Exception when calling MediatorApi->volumesVolumeIDGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();
my $volumeID = volumeID_example; # String | the volume name
my $targetVolumeID = targetVolumeID_example; # String | The name of the downloaded volume. If not specified then it is equal to volumeID 

eval { 
    $api_instance->volumesVolumeIDGet(volumeID => $volumeID, targetVolumeID => $targetVolumeID);
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesVolumeIDGet: $@\n";
}

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()
volumeID = volumeID_example # String | the volume name (default to null)
targetVolumeID = targetVolumeID_example # String | The name of the downloaded volume. If not specified then it is equal to volumeID  (optional) (default to null)

try: 
    api_instance.volumes_volume_id_get(volumeID, targetVolumeID=targetVolumeID)
except ApiException as e:
    print("Exception when calling MediatorApi->volumesVolumeIDGet: %s\n" % e)

extern crate MediatorApi;

pub fn main() {
    let volumeID = volumeID_example; // String
    let targetVolumeID = targetVolumeID_example; // String

    let mut context = MediatorApi::Context::default();
    let result = client.volumesVolumeIDGet(volumeID, targetVolumeID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String the volume name Required

Query parameters

Name	Description
targetVolumeID	String The name of the downloaded volume. If not specified then it is equal to volumeID

Responses

/volumes/{volumeID}/info

Returns basic information for the specified volume.

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
 "http://localhost/volumes/{volumeID}/info"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        String volumeID = volumeID_example; // String | the volume name
        
        try {
            apiInstance.volumesVolumeIDInfoGet(volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDInfoGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

public class MediatorApiExample {
    public static void main(String[] args) {
        MediatorApi apiInstance = new MediatorApi();
        String volumeID = volumeID_example; // String | the volume name
        
        try {
            apiInstance.volumesVolumeIDInfoGet(volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDInfoGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];
String *volumeID = volumeID_example; // the volume name (default to null)

[apiInstance volumesVolumeIDInfoGetWith:volumeID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var volumeID = volumeID_example; // {String} the volume name

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class volumesVolumeIDInfoGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();
            var volumeID = volumeID_example;  // String | the volume name (default to null)

            try {
                apiInstance.volumesVolumeIDInfoGet(volumeID);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDInfoGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();
$volumeID = volumeID_example; // String | the volume name

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();
my $volumeID = volumeID_example; # String | the volume name

eval { 
    $api_instance->volumesVolumeIDInfoGet(volumeID => $volumeID);
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesVolumeIDInfoGet: $@\n";
}

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()
volumeID = volumeID_example # String | the volume name (default to null)

try: 
    api_instance.volumes_volume_id_info_get(volumeID)
except ApiException as e:
    print("Exception when calling MediatorApi->volumesVolumeIDInfoGet: %s\n" % e)

extern crate MediatorApi;

pub fn main() {
    let volumeID = volumeID_example; // String

    let mut context = MediatorApi::Context::default();
    let result = client.volumesVolumeIDInfoGet(volumeID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String the volume name Required

Responses

/volumes/{volumeID}

Manages the specified volume.

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
 "http://localhost/volumes/{volumeID}?action="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        String action = action_example; // String | * `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `rename` - Renames the specified volume to the given target name.
* `compress` - Compresses the storage of the specified volume.
* `backup` - Creates a backup for the specified volume.
* `copy` - Copies the specified volume to a new volume with the given target name.
* `upgradeBlockFileSystem` - Upgrades the BlockFileSystem of the specified volume
        String volumeID = volumeID_example; // String | the volume name
        
        try {
            apiInstance.volumesVolumeIDPost(action, volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

public class MediatorApiExample {
    public static void main(String[] args) {
        MediatorApi apiInstance = new MediatorApi();
        String action = action_example; // String | * `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `rename` - Renames the specified volume to the given target name.
* `compress` - Compresses the storage of the specified volume.
* `backup` - Creates a backup for the specified volume.
* `copy` - Copies the specified volume to a new volume with the given target name.
* `upgradeBlockFileSystem` - Upgrades the BlockFileSystem of the specified volume
        String volumeID = volumeID_example; // String | the volume name
        
        try {
            apiInstance.volumesVolumeIDPost(action, volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];
String *action = action_example; // * `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `rename` - Renames the specified volume to the given target name.
* `compress` - Compresses the storage of the specified volume.
* `backup` - Creates a backup for the specified volume.
* `copy` - Copies the specified volume to a new volume with the given target name.
* `upgradeBlockFileSystem` - Upgrades the BlockFileSystem of the specified volume (default to null)
String *volumeID = volumeID_example; // the volume name (default to null)

[apiInstance volumesVolumeIDPostWith:action
    volumeID:volumeID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var action = action_example; // {String} * `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `rename` - Renames the specified volume to the given target name.
* `compress` - Compresses the storage of the specified volume.
* `backup` - Creates a backup for the specified volume.
* `copy` - Copies the specified volume to a new volume with the given target name.
* `upgradeBlockFileSystem` - Upgrades the BlockFileSystem of the specified volume
var volumeID = volumeID_example; // {String} the volume name

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class volumesVolumeIDPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();
            var action = action_example;  // String | * `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `rename` - Renames the specified volume to the given target name.
* `compress` - Compresses the storage of the specified volume.
* `backup` - Creates a backup for the specified volume.
* `copy` - Copies the specified volume to a new volume with the given target name.
* `upgradeBlockFileSystem` - Upgrades the BlockFileSystem of the specified volume (default to null)
            var volumeID = volumeID_example;  // String | the volume name (default to null)

            try {
                apiInstance.volumesVolumeIDPost(action, volumeID);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDPost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();
$action = action_example; // String | * `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `rename` - Renames the specified volume to the given target name.
* `compress` - Compresses the storage of the specified volume.
* `backup` - Creates a backup for the specified volume.
* `copy` - Copies the specified volume to a new volume with the given target name.
* `upgradeBlockFileSystem` - Upgrades the BlockFileSystem of the specified volume
$volumeID = volumeID_example; // String | the volume name

try {
    $api_instance->volumesVolumeIDPost($action, $volumeID);
} catch (Exception $e) {
    echo 'Exception when calling MediatorApi->volumesVolumeIDPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();
my $action = action_example; # String | * `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `rename` - Renames the specified volume to the given target name.
* `compress` - Compresses the storage of the specified volume.
* `backup` - Creates a backup for the specified volume.
* `copy` - Copies the specified volume to a new volume with the given target name.
* `upgradeBlockFileSystem` - Upgrades the BlockFileSystem of the specified volume
my $volumeID = volumeID_example; # String | the volume name

eval { 
    $api_instance->volumesVolumeIDPost(action => $action, volumeID => $volumeID);
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesVolumeIDPost: $@\n";
}

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()
action = action_example # String | * `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `rename` - Renames the specified volume to the given target name.
* `compress` - Compresses the storage of the specified volume.
* `backup` - Creates a backup for the specified volume.
* `copy` - Copies the specified volume to a new volume with the given target name.
* `upgradeBlockFileSystem` - Upgrades the BlockFileSystem of the specified volume (default to null)
volumeID = volumeID_example # String | the volume name (default to null)

try: 
    api_instance.volumes_volume_id_post(action, volumeID)
except ApiException as e:
    print("Exception when calling MediatorApi->volumesVolumeIDPost: %s\n" % e)

extern crate MediatorApi;

pub fn main() {
    let action = action_example; // String
    let volumeID = volumeID_example; // String

    let mut context = MediatorApi::Context::default();
    let result = client.volumesVolumeIDPost(action, volumeID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String the volume name Required

Query parameters

Name	Description
action*	String * `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!) * `rename` - Renames the specified volume to the given target name. * `compress` - Compresses the storage of the specified volume. * `backup` - Creates a backup for the specified volume. * `copy` - Copies the specified volume to a new volume with the given target name. * `upgradeBlockFileSystem` - Upgrades the BlockFileSystem of the specified volume Required

Name

Description

action*

String

* `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!) * `rename` - Renames the specified volume to the given target name. * `compress` - Compresses the storage of the specified volume. * `backup` - Creates a backup for the specified volume. * `copy` - Copies the specified volume to a new volume with the given target name. * `upgradeBlockFileSystem` - Upgrades the BlockFileSystem of the specified volume

Required

Responses

/volumes/{volumeID}

Replaces the specified volume with the uploaded volume. This resource requires a volume zip file attached to the request.

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Basic [[basicHash]]"\
 "http://localhost/volumes/{volumeID}?sourceVolumeID="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MediatorApi;

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

public class MediatorApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");
        
        // Create an instance of the API class
        MediatorApi apiInstance = new MediatorApi();
        String volumeID = volumeID_example; // String | the volume name
        String sourceVolumeID = sourceVolumeID_example; // String | The name of the uploaded volume. If not specified then it is assumed that it is equals to the target volume ID
        
        try {
            apiInstance.volumesVolumeIDPut(volumeID, sourceVolumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDPut");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

public class MediatorApiExample {
    public static void main(String[] args) {
        MediatorApi apiInstance = new MediatorApi();
        String volumeID = volumeID_example; // String | the volume name
        String sourceVolumeID = sourceVolumeID_example; // String | The name of the uploaded volume. If not specified then it is assumed that it is equals to the target volume ID
        
        try {
            apiInstance.volumesVolumeIDPut(volumeID, sourceVolumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MediatorApi *apiInstance = [[MediatorApi alloc] init];
String *volumeID = volumeID_example; // the volume name (default to null)
String *sourceVolumeID = sourceVolumeID_example; // The name of the uploaded volume. If not specified then it is assumed that it is equals to the target volume ID (optional) (default to null)

[apiInstance volumesVolumeIDPutWith:volumeID
    sourceVolumeID:sourceVolumeID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var Mediator = require('mediator');
var defaultClient = Mediator.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME';
Basic.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new Mediator.MediatorApi()
var volumeID = volumeID_example; // {String} the volume name
var opts = {
  'sourceVolumeID': sourceVolumeID_example // {String} The name of the uploaded volume. If not specified then it is assumed that it is equals to the target volume ID
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class volumesVolumeIDPutExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            
            // Create an instance of the API class
            var apiInstance = new MediatorApi();
            var volumeID = volumeID_example;  // String | the volume name (default to null)
            var sourceVolumeID = sourceVolumeID_example;  // String | The name of the uploaded volume. If not specified then it is assumed that it is equals to the target volume ID (optional)  (default to null)

            try {
                apiInstance.volumesVolumeIDPut(volumeID, sourceVolumeID);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MediatorApi();
$volumeID = volumeID_example; // String | the volume name
$sourceVolumeID = sourceVolumeID_example; // String | The name of the uploaded volume. If not specified then it is assumed that it is equals to the target volume ID

try {
    $api_instance->volumesVolumeIDPut($volumeID, $sourceVolumeID);
} catch (Exception $e) {
    echo 'Exception when calling MediatorApi->volumesVolumeIDPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MediatorApi;

# Configure HTTP basic authorization: Basic
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MediatorApi->new();
my $volumeID = volumeID_example; # String | the volume name
my $sourceVolumeID = sourceVolumeID_example; # String | The name of the uploaded volume. If not specified then it is assumed that it is equals to the target volume ID

eval { 
    $api_instance->volumesVolumeIDPut(volumeID => $volumeID, sourceVolumeID => $sourceVolumeID);
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesVolumeIDPut: $@\n";
}

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

# Configure HTTP basic authorization: Basic
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MediatorApi()
volumeID = volumeID_example # String | the volume name (default to null)
sourceVolumeID = sourceVolumeID_example # String | The name of the uploaded volume. If not specified then it is assumed that it is equals to the target volume ID (optional) (default to null)

try: 
    api_instance.volumes_volume_id_put(volumeID, sourceVolumeID=sourceVolumeID)
except ApiException as e:
    print("Exception when calling MediatorApi->volumesVolumeIDPut: %s\n" % e)

extern crate MediatorApi;

pub fn main() {
    let volumeID = volumeID_example; // String
    let sourceVolumeID = sourceVolumeID_example; // String

    let mut context = MediatorApi::Context::default();
    let result = client.volumesVolumeIDPut(volumeID, sourceVolumeID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String the volume name Required

Query parameters

Name	Description
sourceVolumeID	String The name of the uploaded volume. If not specified then it is assumed that it is equals to the target volume ID

Mediator

API and SDK Documentation

Mediator

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses

Usage and SDK Samples

Scopes

Parameters

Responses