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 GET\
 "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.oauthRedirectGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#oauthRedirectGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

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



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

[apiInstance oauthRedirectGetWithCompletionHandler: 
              ^(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.oauthRedirectGet(callback);

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

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

            try {
                apiInstance.oauthRedirectGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.oauthRedirectGet: " + 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->oauthRedirectGet();
} catch (Exception $e) {
    echo 'Exception when calling MediatorApi->oauthRedirectGet: ', $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->oauthRedirectGet();
};
if ($@) {
    warn "Exception when calling MediatorApi->oauthRedirectGet: $@\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_get()
except ApiException as e:
    print("Exception when calling MediatorApi->oauthRedirectGet: %s\n" % e)

extern crate MediatorApi;

pub fn main() {

    let mut context = MediatorApi::Context::default();
    let result = client.oauthRedirectGet(&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}/accounts

Returns a list of all accounts of the volume. Note: password hashes are not contained in the response.

Usage and SDK Samples

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

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 | Volume name
        
        try {
            apiInstance.volumesVolumeIDAccountsGet(volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDAccountsGet");
            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 | Volume name
        
        try {
            apiInstance.volumesVolumeIDAccountsGet(volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDAccountsGet");
            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; // Volume name (default to null)

[apiInstance volumesVolumeIDAccountsGetWith: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} Volume name

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

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

namespace Example
{
    public class volumesVolumeIDAccountsGetExample
    {
        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 | Volume name (default to null)

            try {
                apiInstance.volumesVolumeIDAccountsGet(volumeID);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDAccountsGet: " + 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 | Volume name

try {
    $api_instance->volumesVolumeIDAccountsGet($volumeID);
} catch (Exception $e) {
    echo 'Exception when calling MediatorApi->volumesVolumeIDAccountsGet: ', $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 | Volume name

eval { 
    $api_instance->volumesVolumeIDAccountsGet(volumeID => $volumeID);
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesVolumeIDAccountsGet: $@\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 | Volume name (default to null)

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

extern crate MediatorApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String Volume name Required

Responses

/volumes/{volumeID}/accounts

Creates or updates an account. Updating an account requires the UUID of the account to be present in the data.

Usage and SDK Samples

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

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 | Volume name
        
        try {
            apiInstance.volumesVolumeIDAccountsPost(volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDAccountsPost");
            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 | Volume name
        
        try {
            apiInstance.volumesVolumeIDAccountsPost(volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDAccountsPost");
            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; // Volume name (default to null)

[apiInstance volumesVolumeIDAccountsPostWith: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} Volume name

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

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

namespace Example
{
    public class volumesVolumeIDAccountsPostExample
    {
        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 | Volume name (default to null)

            try {
                apiInstance.volumesVolumeIDAccountsPost(volumeID);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDAccountsPost: " + 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 | Volume name

try {
    $api_instance->volumesVolumeIDAccountsPost($volumeID);
} catch (Exception $e) {
    echo 'Exception when calling MediatorApi->volumesVolumeIDAccountsPost: ', $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 | Volume name

eval { 
    $api_instance->volumesVolumeIDAccountsPost(volumeID => $volumeID);
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesVolumeIDAccountsPost: $@\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 | Volume name (default to null)

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

extern crate MediatorApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String Volume name Required

Responses

/volumes/{volumeID}/accounts/{userID}

Deletes an account

Usage and SDK Samples

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

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 userID = userID_example; // String | User uuid
        String volumeID = volumeID_example; // String | Volume name
        
        try {
            apiInstance.volumesVolumeIDAccountsUserIDDelete(userID, volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDAccountsUserIDDelete");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MediatorApi;

public class MediatorApiExample {
    public static void main(String[] args) {
        MediatorApi apiInstance = new MediatorApi();
        String userID = userID_example; // String | User uuid
        String volumeID = volumeID_example; // String | Volume name
        
        try {
            apiInstance.volumesVolumeIDAccountsUserIDDelete(userID, volumeID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MediatorApi#volumesVolumeIDAccountsUserIDDelete");
            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 *userID = userID_example; // User uuid (default to null)
String *volumeID = volumeID_example; // Volume name (default to null)

[apiInstance volumesVolumeIDAccountsUserIDDeleteWith:userID
    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 userID = userID_example; // {String} User uuid
var volumeID = volumeID_example; // {String} Volume name

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

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

namespace Example
{
    public class volumesVolumeIDAccountsUserIDDeleteExample
    {
        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 userID = userID_example;  // String | User uuid (default to null)
            var volumeID = volumeID_example;  // String | Volume name (default to null)

            try {
                apiInstance.volumesVolumeIDAccountsUserIDDelete(userID, volumeID);
            } catch (Exception e) {
                Debug.Print("Exception when calling MediatorApi.volumesVolumeIDAccountsUserIDDelete: " + 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();
$userID = userID_example; // String | User uuid
$volumeID = volumeID_example; // String | Volume name

try {
    $api_instance->volumesVolumeIDAccountsUserIDDelete($userID, $volumeID);
} catch (Exception $e) {
    echo 'Exception when calling MediatorApi->volumesVolumeIDAccountsUserIDDelete: ', $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 $userID = userID_example; # String | User uuid
my $volumeID = volumeID_example; # String | Volume name

eval { 
    $api_instance->volumesVolumeIDAccountsUserIDDelete(userID => $userID, volumeID => $volumeID);
};
if ($@) {
    warn "Exception when calling MediatorApi->volumesVolumeIDAccountsUserIDDelete: $@\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()
userID = userID_example # String | User uuid (default to null)
volumeID = volumeID_example # String | Volume name (default to null)

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

extern crate MediatorApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
userID*	String User uuid Required
volumeID*	String Volume name Required

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 | * `start` - Starts / resumes the garbageCollection for the specified volume.
* `pause` - Pauses the garbageCollection ( if active ) 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 | * `start` - Starts / resumes the garbageCollection for the specified volume.
* `pause` - Pauses the garbageCollection ( if active ) 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; // * `start` - Starts / resumes the garbageCollection for the specified volume.
* `pause` - Pauses the garbageCollection ( if active ) 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} * `start` - Starts / resumes the garbageCollection for the specified volume.
* `pause` - Pauses the garbageCollection ( if active ) 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 | * `start` - Starts / resumes the garbageCollection for the specified volume.
* `pause` - Pauses the garbageCollection ( if active ) 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 | * `start` - Starts / resumes the garbageCollection for the specified volume.
* `pause` - Pauses the garbageCollection ( if active ) 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 | * `start` - Starts / resumes the garbageCollection for the specified volume.
* `pause` - Pauses the garbageCollection ( if active ) 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 | * `start` - Starts / resumes the garbageCollection for the specified volume.
* `pause` - Pauses the garbageCollection ( if active ) 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 * `start` - Starts / resumes the garbageCollection for the specified volume. * `pause` - Pauses the garbageCollection ( if active ) 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}?blobs=&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 blobs = blobs_example; // String | True if blobs should be downloaded. Default: false
        String targetVolumeID = targetVolumeID_example; // String | The name of the downloaded volume. If not specified then it is equal to volumeID 
        
        try {
            apiInstance.volumesVolumeIDGet(volumeID, blobs, 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 blobs = blobs_example; // String | True if blobs should be downloaded. Default: false
        String targetVolumeID = targetVolumeID_example; // String | The name of the downloaded volume. If not specified then it is equal to volumeID 
        
        try {
            apiInstance.volumesVolumeIDGet(volumeID, blobs, 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 *blobs = blobs_example; // True if blobs should be downloaded. Default: false (optional) (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
    blobs:blobs
    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 = {
  'blobs': blobs_example, // {String} True if blobs should be downloaded. Default: false
  '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 blobs = blobs_example;  // String | True if blobs should be downloaded. Default: false (optional)  (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, blobs, 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
$blobs = blobs_example; // String | True if blobs should be downloaded. Default: false
$targetVolumeID = targetVolumeID_example; // String | The name of the downloaded volume. If not specified then it is equal to volumeID 

try {
    $api_instance->volumesVolumeIDGet($volumeID, $blobs, $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 $blobs = blobs_example; # String | True if blobs should be downloaded. Default: false
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, blobs => $blobs, 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)
blobs = blobs_example # String | True if blobs should be downloaded. Default: false (optional) (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, blobs=blobs, 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 blobs = blobs_example; // String
    let targetVolumeID = targetVolumeID_example; // String

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

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

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String the volume name Required

Query parameters

Name	Description
blobs	String True if blobs should be downloaded. Default: false
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}

Creates an backup for the specified volume.

Usage and SDK Samples

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

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 | * `backup` - Creates a backup for the specified volume.
* `recover` - Recovers the specified volume
* `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `compress` - Compresses the storage of the specified volume.
* `rename` - Renames the specified volume to the given target name.
* `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
        Boolean waitUntilFinished = true; // Boolean | Indicates if the request should block until the backup is fully completed (`true`) or only until the exclusive part of the backup is completed (`false` - default value). Depending on the volume size it can take quite some time untila a backup is fully completed.
        
        try {
            apiInstance.volumesVolumeIDPost(action, volumeID, waitUntilFinished);
        } 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 | * `backup` - Creates a backup for the specified volume.
* `recover` - Recovers the specified volume
* `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `compress` - Compresses the storage of the specified volume.
* `rename` - Renames the specified volume to the given target name.
* `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
        Boolean waitUntilFinished = true; // Boolean | Indicates if the request should block until the backup is fully completed (`true`) or only until the exclusive part of the backup is completed (`false` - default value). Depending on the volume size it can take quite some time untila a backup is fully completed.
        
        try {
            apiInstance.volumesVolumeIDPost(action, volumeID, waitUntilFinished);
        } 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; // * `backup` - Creates a backup for the specified volume.
* `recover` - Recovers the specified volume
* `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `compress` - Compresses the storage of the specified volume.
* `rename` - Renames the specified volume to the given target name.
* `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)
Boolean *waitUntilFinished = true; // Indicates if the request should block until the backup is fully completed (`true`) or only until the exclusive part of the backup is completed (`false` - default value). Depending on the volume size it can take quite some time untila a backup is fully completed. (optional) (default to null)

[apiInstance volumesVolumeIDPostWith:action
    volumeID:volumeID
    waitUntilFinished:waitUntilFinished
              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} * `backup` - Creates a backup for the specified volume.
* `recover` - Recovers the specified volume
* `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `compress` - Compresses the storage of the specified volume.
* `rename` - Renames the specified volume to the given target name.
* `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 opts = {
  'waitUntilFinished': true // {Boolean} Indicates if the request should block until the backup is fully completed (`true`) or only until the exclusive part of the backup is completed (`false` - default value). Depending on the volume size it can take quite some time untila a backup is fully completed.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.volumesVolumeIDPost(action, volumeID, opts, 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 | * `backup` - Creates a backup for the specified volume.
* `recover` - Recovers the specified volume
* `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `compress` - Compresses the storage of the specified volume.
* `rename` - Renames the specified volume to the given target name.
* `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)
            var waitUntilFinished = true;  // Boolean | Indicates if the request should block until the backup is fully completed (`true`) or only until the exclusive part of the backup is completed (`false` - default value). Depending on the volume size it can take quite some time untila a backup is fully completed. (optional)  (default to null)

            try {
                apiInstance.volumesVolumeIDPost(action, volumeID, waitUntilFinished);
            } 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 | * `backup` - Creates a backup for the specified volume.
* `recover` - Recovers the specified volume
* `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `compress` - Compresses the storage of the specified volume.
* `rename` - Renames the specified volume to the given target name.
* `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
$waitUntilFinished = true; // Boolean | Indicates if the request should block until the backup is fully completed (`true`) or only until the exclusive part of the backup is completed (`false` - default value). Depending on the volume size it can take quite some time untila a backup is fully completed.

try {
    $api_instance->volumesVolumeIDPost($action, $volumeID, $waitUntilFinished);
} 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 | * `backup` - Creates a backup for the specified volume.
* `recover` - Recovers the specified volume
* `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `compress` - Compresses the storage of the specified volume.
* `rename` - Renames the specified volume to the given target name.
* `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
my $waitUntilFinished = true; # Boolean | Indicates if the request should block until the backup is fully completed (`true`) or only until the exclusive part of the backup is completed (`false` - default value). Depending on the volume size it can take quite some time untila a backup is fully completed.

eval { 
    $api_instance->volumesVolumeIDPost(action => $action, volumeID => $volumeID, waitUntilFinished => $waitUntilFinished);
};
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 | * `backup` - Creates a backup for the specified volume.
* `recover` - Recovers the specified volume
* `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!)
* `compress` - Compresses the storage of the specified volume.
* `rename` - Renames the specified volume to the given target name.
* `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)
waitUntilFinished = true # Boolean | Indicates if the request should block until the backup is fully completed (`true`) or only until the exclusive part of the backup is completed (`false` - default value). Depending on the volume size it can take quite some time untila a backup is fully completed. (optional) (default to null)

try: 
    api_instance.volumes_volume_id_post(action, volumeID, waitUntilFinished=waitUntilFinished)
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 waitUntilFinished = true; // Boolean

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

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

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String the volume name Required

Query parameters

Name	Description
action*	String * `backup` - Creates a backup for the specified volume. * `recover` - Recovers the specified volume * `upgradeCoastVersion` - Upgrades the volume to the current Coast-Version (Attention: This process is irreversible!!) * `compress` - Compresses the storage of the specified volume. * `rename` - Renames the specified volume to the given target name. * `copy` - Copies the specified volume to a new volume with the given target name. * `upgradeBlockFileSystem` - Upgrades the BlockFileSystem of the specified volume Required
waitUntilFinished	Boolean Indicates if the request should block until the backup is fully completed (`true`) or only until the exclusive part of the backup is completed (`false` - default value). Depending on the volume size it can take quite some time untila a backup is fully completed.

Name

Description

action*

String

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

Required

waitUntilFinished

Boolean

Indicates if the request should block until the backup is fully completed (`true`) or only until the exclusive part of the backup is completed (`false` - default value). Depending on the volume size it can take quite some time untila a backup is fully completed.

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}?keepAuthentication=&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 keepAuthentication = keepAuthentication_example; // String | Comma-separated list of account names whose authentications are transferred from the previous volume. Wildcards are supported. Example: KUser:Administrator,Service:*
        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, keepAuthentication, 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 keepAuthentication = keepAuthentication_example; // String | Comma-separated list of account names whose authentications are transferred from the previous volume. Wildcards are supported. Example: KUser:Administrator,Service:*
        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, keepAuthentication, 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 *keepAuthentication = keepAuthentication_example; // Comma-separated list of account names whose authentications are transferred from the previous volume. Wildcards are supported. Example: KUser:Administrator,Service:* (optional) (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
    keepAuthentication:keepAuthentication
    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 = {
  'keepAuthentication': keepAuthentication_example, // {String} Comma-separated list of account names whose authentications are transferred from the previous volume. Wildcards are supported. Example: KUser:Administrator,Service:*
  '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 keepAuthentication = keepAuthentication_example;  // String | Comma-separated list of account names whose authentications are transferred from the previous volume. Wildcards are supported. Example: KUser:Administrator,Service:* (optional)  (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, keepAuthentication, 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
$keepAuthentication = keepAuthentication_example; // String | Comma-separated list of account names whose authentications are transferred from the previous volume. Wildcards are supported. Example: KUser:Administrator,Service:*
$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, $keepAuthentication, $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 $keepAuthentication = keepAuthentication_example; # String | Comma-separated list of account names whose authentications are transferred from the previous volume. Wildcards are supported. Example: KUser:Administrator,Service:*
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, keepAuthentication => $keepAuthentication, 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)
keepAuthentication = keepAuthentication_example # String | Comma-separated list of account names whose authentications are transferred from the previous volume. Wildcards are supported. Example: KUser:Administrator,Service:* (optional) (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, keepAuthentication=keepAuthentication, 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 keepAuthentication = keepAuthentication_example; // String
    let sourceVolumeID = sourceVolumeID_example; // String

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

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

Scopes

Parameters

Path parameters

Name	Description
volumeID*	String the volume name Required

Query parameters

Name	Description
keepAuthentication	String Comma-separated list of account names whose authentications are transferred from the previous volume. Wildcards are supported. Example: KUser:Administrator,Service:*
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

Usage and SDK Samples