Okapi Core API Facade

Deployment

deleteDeployedModuleInstance

Shutdown instance

/_/deployment/modules/{instance_id}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:8081/_/deployment/modules/{instance_id}"

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

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

public class DeploymentApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DeploymentApi apiInstance = new DeploymentApi();
        String instanceId = instanceId_example; // String | 

        try {
            apiInstance.deleteDeployedModuleInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#deleteDeployedModuleInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | 

try {
    final result = await api_instance.deleteDeployedModuleInstance(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteDeployedModuleInstance: $e\n');
}

import org.openapitools.client.api.DeploymentApi;

public class DeploymentApiExample {
    public static void main(String[] args) {
        DeploymentApi apiInstance = new DeploymentApi();
        String instanceId = instanceId_example; // String | 

        try {
            apiInstance.deleteDeployedModuleInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#deleteDeployedModuleInstance");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DeploymentApi *apiInstance = [[DeploymentApi alloc] init];
String *instanceId = instanceId_example; //  (default to null)

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.DeploymentApi()
var instanceId = instanceId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DeploymentApi();
            var instanceId = instanceId_example;  // String |  (default to null)

            try {
                apiInstance.deleteDeployedModuleInstance(instanceId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DeploymentApi.deleteDeployedModuleInstance: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DeploymentApi();
$instanceId = instanceId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DeploymentApi->new();
my $instanceId = instanceId_example; # String | 

eval {
    $api_instance->deleteDeployedModuleInstance(instanceId => $instanceId);
};
if ($@) {
    warn "Exception when calling DeploymentApi->deleteDeployedModuleInstance: $@\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.DeploymentApi()
instanceId = instanceId_example # String |  (default to null)

try:
    api_instance.delete_deployed_module_instance(instanceId)
except ApiException as e:
    print("Exception when calling DeploymentApi->deleteDeployedModuleInstance: %s\n" % e)

extern crate DeploymentApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = DeploymentApi::Context::default();
    let result = client.deleteDeployedModuleInstance(instanceId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
instance_id*	String Required

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

deployModuleInstance

Deploy (launch process, start a container, etc) instance of a particular service, according to the deployment descriptor.

/_/deployment/modules

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/deployment/modules" \
 -d '{
  "instId" : "instId",
  "descriptor" : "{}",
  "srvcId" : "srvcId",
  "nodeId" : "nodeId",
  "url" : "url"
}'

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

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

public class DeploymentApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DeploymentApi apiInstance = new DeploymentApi();
        DeploymentDescriptor deploymentDescriptor = ; // DeploymentDescriptor | 

        try {
            DeploymentDescriptor result = apiInstance.deployModuleInstance(deploymentDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#deployModuleInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final DeploymentDescriptor deploymentDescriptor = new DeploymentDescriptor(); // DeploymentDescriptor | 

try {
    final result = await api_instance.deployModuleInstance(deploymentDescriptor);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deployModuleInstance: $e\n');
}

import org.openapitools.client.api.DeploymentApi;

public class DeploymentApiExample {
    public static void main(String[] args) {
        DeploymentApi apiInstance = new DeploymentApi();
        DeploymentDescriptor deploymentDescriptor = ; // DeploymentDescriptor | 

        try {
            DeploymentDescriptor result = apiInstance.deployModuleInstance(deploymentDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#deployModuleInstance");
            e.printStackTrace();
        }
    }
}



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

[apiInstance deployModuleInstanceWith:deploymentDescriptor
              completionHandler: ^(DeploymentDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.DeploymentApi()
var deploymentDescriptor = ; // {DeploymentDescriptor} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DeploymentApi();
            var deploymentDescriptor = new DeploymentDescriptor(); // DeploymentDescriptor | 

            try {
                DeploymentDescriptor result = apiInstance.deployModuleInstance(deploymentDescriptor);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DeploymentApi.deployModuleInstance: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DeploymentApi();
$deploymentDescriptor = ; // DeploymentDescriptor | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DeploymentApi->new();
my $deploymentDescriptor = WWW::OPenAPIClient::Object::DeploymentDescriptor->new(); # DeploymentDescriptor | 

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

try:
    api_response = api_instance.deploy_module_instance(deploymentDescriptor)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DeploymentApi->deployModuleInstance: %s\n" % e)

extern crate DeploymentApi;

pub fn main() {
    let deploymentDescriptor = ; // DeploymentDescriptor

    let mut context = DeploymentApi::Context::default();
    let result = client.deployModuleInstance(deploymentDescriptor, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
deploymentDescriptor *

Name	Type	Format	Description
Location	String		URI to the environment entry instance
X-Okapi-Trace	String

getAllDeployedModuleInstances

List all deployed instances

/_/deployment/modules

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/deployment/modules"

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

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

public class DeploymentApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DeploymentApi apiInstance = new DeploymentApi();

        try {
            array[DeploymentDescriptor] result = apiInstance.getAllDeployedModuleInstances();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getAllDeployedModuleInstances");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getAllDeployedModuleInstances();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllDeployedModuleInstances: $e\n');
}

import org.openapitools.client.api.DeploymentApi;

public class DeploymentApiExample {
    public static void main(String[] args) {
        DeploymentApi apiInstance = new DeploymentApi();

        try {
            array[DeploymentDescriptor] result = apiInstance.getAllDeployedModuleInstances();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getAllDeployedModuleInstances");
            e.printStackTrace();
        }
    }
}



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

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

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

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

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

            // Create an instance of the API class
            var apiInstance = new DeploymentApi();

            try {
                array[DeploymentDescriptor] result = apiInstance.getAllDeployedModuleInstances();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DeploymentApi.getAllDeployedModuleInstances: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate DeploymentApi;

pub fn main() {

    let mut context = DeploymentApi::Context::default();
    let result = client.getAllDeployedModuleInstances(&context).wait();

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

Scopes

Parameters

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getDeployedModuleInstance

Retrieve deployment descriptor for a particular instance

/_/deployment/modules/{instance_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/deployment/modules/{instance_id}"

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

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

public class DeploymentApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DeploymentApi apiInstance = new DeploymentApi();
        String instanceId = instanceId_example; // String | 

        try {
            DeploymentDescriptor result = apiInstance.getDeployedModuleInstance(instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getDeployedModuleInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | 

try {
    final result = await api_instance.getDeployedModuleInstance(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getDeployedModuleInstance: $e\n');
}

import org.openapitools.client.api.DeploymentApi;

public class DeploymentApiExample {
    public static void main(String[] args) {
        DeploymentApi apiInstance = new DeploymentApi();
        String instanceId = instanceId_example; // String | 

        try {
            DeploymentDescriptor result = apiInstance.getDeployedModuleInstance(instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getDeployedModuleInstance");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DeploymentApi *apiInstance = [[DeploymentApi alloc] init];
String *instanceId = instanceId_example; //  (default to null)

[apiInstance getDeployedModuleInstanceWith:instanceId
              completionHandler: ^(DeploymentDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.DeploymentApi()
var instanceId = instanceId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DeploymentApi();
            var instanceId = instanceId_example;  // String |  (default to null)

            try {
                DeploymentDescriptor result = apiInstance.getDeployedModuleInstance(instanceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DeploymentApi.getDeployedModuleInstance: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DeploymentApi();
$instanceId = instanceId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DeploymentApi->new();
my $instanceId = instanceId_example; # String | 

eval {
    my $result = $api_instance->getDeployedModuleInstance(instanceId => $instanceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DeploymentApi->getDeployedModuleInstance: $@\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.DeploymentApi()
instanceId = instanceId_example # String |  (default to null)

try:
    api_response = api_instance.get_deployed_module_instance(instanceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DeploymentApi->getDeployedModuleInstance: %s\n" % e)

extern crate DeploymentApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = DeploymentApi::Context::default();
    let result = client.getDeployedModuleInstance(instanceId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
instance_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

Discovery

createDiscovery

/_/discovery/modules

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/discovery/modules" \
 -d '{
  "instId" : "instId",
  "descriptor" : "{}",
  "srvcId" : "srvcId",
  "nodeId" : "nodeId",
  "url" : "url"
}'

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();
        DeploymentDescriptor deploymentDescriptor = ; // DeploymentDescriptor | 

        try {
            DeploymentDescriptor result = apiInstance.createDiscovery(deploymentDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#createDiscovery");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final DeploymentDescriptor deploymentDescriptor = new DeploymentDescriptor(); // DeploymentDescriptor | 

try {
    final result = await api_instance.createDiscovery(deploymentDescriptor);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createDiscovery: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();
        DeploymentDescriptor deploymentDescriptor = ; // DeploymentDescriptor | 

        try {
            DeploymentDescriptor result = apiInstance.createDiscovery(deploymentDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#createDiscovery");
            e.printStackTrace();
        }
    }
}



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

[apiInstance createDiscoveryWith:deploymentDescriptor
              completionHandler: ^(DeploymentDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.DiscoveryApi()
var deploymentDescriptor = ; // {DeploymentDescriptor} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();
            var deploymentDescriptor = new DeploymentDescriptor(); // DeploymentDescriptor | 

            try {
                DeploymentDescriptor result = apiInstance.createDiscovery(deploymentDescriptor);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryApi.createDiscovery: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryApi();
$deploymentDescriptor = ; // DeploymentDescriptor | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryApi->new();
my $deploymentDescriptor = WWW::OPenAPIClient::Object::DeploymentDescriptor->new(); # DeploymentDescriptor | 

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

try:
    api_response = api_instance.create_discovery(deploymentDescriptor)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryApi->createDiscovery: %s\n" % e)

extern crate DiscoveryApi;

pub fn main() {
    let deploymentDescriptor = ; // DeploymentDescriptor

    let mut context = DiscoveryApi::Context::default();
    let result = client.createDiscovery(deploymentDescriptor, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
deploymentDescriptor *

Responses

Schema
Headers

Name	Type	Format	Description
Location	String		URI to the environment entry instance
X-Okapi-Trace	String

deleteAllDiscoveries

Delete all instances

/_/discovery/modules

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:8081/_/discovery/modules"

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();

        try {
            apiInstance.deleteAllDiscoveries();
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#deleteAllDiscoveries");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.deleteAllDiscoveries();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteAllDiscoveries: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();

        try {
            apiInstance.deleteAllDiscoveries();
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#deleteAllDiscoveries");
            e.printStackTrace();
        }
    }
}



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

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();

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

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

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

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

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

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

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

try:
    api_instance.delete_all_discoveries()
except ApiException as e:
    print("Exception when calling DiscoveryApi->deleteAllDiscoveries: %s\n" % e)

extern crate DiscoveryApi;

pub fn main() {

    let mut context = DiscoveryApi::Context::default();
    let result = client.deleteAllDiscoveries(&context).wait();

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

Scopes

Parameters

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

deleteDiscoveriesByService

Remove registration for a given instance

/_/discovery/modules/{service_id}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:8081/_/discovery/modules/{service_id}"

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();
        String serviceId = serviceId_example; // String | 

        try {
            apiInstance.deleteDiscoveriesByService(serviceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#deleteDiscoveriesByService");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String serviceId = new String(); // String | 

try {
    final result = await api_instance.deleteDiscoveriesByService(serviceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteDiscoveriesByService: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();
        String serviceId = serviceId_example; // String | 

        try {
            apiInstance.deleteDiscoveriesByService(serviceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#deleteDiscoveriesByService");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DiscoveryApi *apiInstance = [[DiscoveryApi alloc] init];
String *serviceId = serviceId_example; //  (default to null)

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.DiscoveryApi()
var serviceId = serviceId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();
            var serviceId = serviceId_example;  // String |  (default to null)

            try {
                apiInstance.deleteDiscoveriesByService(serviceId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryApi.deleteDiscoveriesByService: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryApi();
$serviceId = serviceId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryApi->new();
my $serviceId = serviceId_example; # String | 

eval {
    $api_instance->deleteDiscoveriesByService(serviceId => $serviceId);
};
if ($@) {
    warn "Exception when calling DiscoveryApi->deleteDiscoveriesByService: $@\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.DiscoveryApi()
serviceId = serviceId_example # String |  (default to null)

try:
    api_instance.delete_discoveries_by_service(serviceId)
except ApiException as e:
    print("Exception when calling DiscoveryApi->deleteDiscoveriesByService: %s\n" % e)

extern crate DiscoveryApi;

pub fn main() {
    let serviceId = serviceId_example; // String

    let mut context = DiscoveryApi::Context::default();
    let result = client.deleteDiscoveriesByService(serviceId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
service_id*	String Required

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

deleteDiscoveryByInstance

Remove registration for a given instance

/_/discovery/modules/{service_id}/{instance_id}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:8081/_/discovery/modules/{service_id}/{instance_id}"

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();
        String instanceId = instanceId_example; // String | 
        String serviceId = serviceId_example; // String | 

        try {
            apiInstance.deleteDiscoveryByInstance(instanceId, serviceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#deleteDiscoveryByInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | 
final String serviceId = new String(); // String | 

try {
    final result = await api_instance.deleteDiscoveryByInstance(instanceId, serviceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteDiscoveryByInstance: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();
        String instanceId = instanceId_example; // String | 
        String serviceId = serviceId_example; // String | 

        try {
            apiInstance.deleteDiscoveryByInstance(instanceId, serviceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#deleteDiscoveryByInstance");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DiscoveryApi *apiInstance = [[DiscoveryApi alloc] init];
String *instanceId = instanceId_example; //  (default to null)
String *serviceId = serviceId_example; //  (default to null)

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.DiscoveryApi()
var instanceId = instanceId_example; // {String} 
var serviceId = serviceId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();
            var instanceId = instanceId_example;  // String |  (default to null)
            var serviceId = serviceId_example;  // String |  (default to null)

            try {
                apiInstance.deleteDiscoveryByInstance(instanceId, serviceId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryApi.deleteDiscoveryByInstance: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryApi();
$instanceId = instanceId_example; // String | 
$serviceId = serviceId_example; // String | 

try {
    $api_instance->deleteDiscoveryByInstance($instanceId, $serviceId);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryApi->deleteDiscoveryByInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryApi->new();
my $instanceId = instanceId_example; # String | 
my $serviceId = serviceId_example; # String | 

eval {
    $api_instance->deleteDiscoveryByInstance(instanceId => $instanceId, serviceId => $serviceId);
};
if ($@) {
    warn "Exception when calling DiscoveryApi->deleteDiscoveryByInstance: $@\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.DiscoveryApi()
instanceId = instanceId_example # String |  (default to null)
serviceId = serviceId_example # String |  (default to null)

try:
    api_instance.delete_discovery_by_instance(instanceId, serviceId)
except ApiException as e:
    print("Exception when calling DiscoveryApi->deleteDiscoveryByInstance: %s\n" % e)

extern crate DiscoveryApi;

pub fn main() {
    let instanceId = instanceId_example; // String
    let serviceId = serviceId_example; // String

    let mut context = DiscoveryApi::Context::default();
    let result = client.deleteDiscoveryByInstance(instanceId, serviceId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
instance_id*	String Required
service_id*	String Required

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getAllDiscoveries

Return all instances

/_/discovery/modules

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/discovery/modules"

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();

        try {
            array[DeploymentDescriptor] result = apiInstance.getAllDiscoveries();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getAllDiscoveries");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getAllDiscoveries();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllDiscoveries: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();

        try {
            array[DeploymentDescriptor] result = apiInstance.getAllDiscoveries();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getAllDiscoveries");
            e.printStackTrace();
        }
    }
}



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

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();

            try {
                array[DeploymentDescriptor] result = apiInstance.getAllDiscoveries();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryApi.getAllDiscoveries: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate DiscoveryApi;

pub fn main() {

    let mut context = DiscoveryApi::Context::default();
    let result = client.getAllDiscoveries(&context).wait();

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

Scopes

Parameters

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getAllDiscoveryHealth

Get health info for all services

/_/discovery/health

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/discovery/health"

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();

        try {
            array[HealthDescriptor] result = apiInstance.getAllDiscoveryHealth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getAllDiscoveryHealth");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getAllDiscoveryHealth();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllDiscoveryHealth: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();

        try {
            array[HealthDescriptor] result = apiInstance.getAllDiscoveryHealth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getAllDiscoveryHealth");
            e.printStackTrace();
        }
    }
}



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

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();

            try {
                array[HealthDescriptor] result = apiInstance.getAllDiscoveryHealth();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryApi.getAllDiscoveryHealth: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate DiscoveryApi;

pub fn main() {

    let mut context = DiscoveryApi::Context::default();
    let result = client.getAllDiscoveryHealth(&context).wait();

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

Scopes

Parameters

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getAllDiscoveryNodes

Get list of all nodes

/_/discovery/nodes

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/discovery/nodes"

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();

        try {
            array[NodeDescriptor] result = apiInstance.getAllDiscoveryNodes();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getAllDiscoveryNodes");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getAllDiscoveryNodes();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllDiscoveryNodes: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();

        try {
            array[NodeDescriptor] result = apiInstance.getAllDiscoveryNodes();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getAllDiscoveryNodes");
            e.printStackTrace();
        }
    }
}



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

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();

            try {
                array[NodeDescriptor] result = apiInstance.getAllDiscoveryNodes();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryApi.getAllDiscoveryNodes: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate DiscoveryApi;

pub fn main() {

    let mut context = DiscoveryApi::Context::default();
    let result = client.getAllDiscoveryNodes(&context).wait();

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

Scopes

Parameters

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getDiscoveriesByService

List all instances for a particular service

/_/discovery/modules/{service_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/discovery/modules/{service_id}"

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();
        String serviceId = serviceId_example; // String | 

        try {
            array[DeploymentDescriptor] result = apiInstance.getDiscoveriesByService(serviceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getDiscoveriesByService");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String serviceId = new String(); // String | 

try {
    final result = await api_instance.getDiscoveriesByService(serviceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getDiscoveriesByService: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();
        String serviceId = serviceId_example; // String | 

        try {
            array[DeploymentDescriptor] result = apiInstance.getDiscoveriesByService(serviceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getDiscoveriesByService");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DiscoveryApi *apiInstance = [[DiscoveryApi alloc] init];
String *serviceId = serviceId_example; //  (default to null)

[apiInstance getDiscoveriesByServiceWith:serviceId
              completionHandler: ^(array[DeploymentDescriptor] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.DiscoveryApi()
var serviceId = serviceId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();
            var serviceId = serviceId_example;  // String |  (default to null)

            try {
                array[DeploymentDescriptor] result = apiInstance.getDiscoveriesByService(serviceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryApi.getDiscoveriesByService: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryApi();
$serviceId = serviceId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryApi->new();
my $serviceId = serviceId_example; # String | 

eval {
    my $result = $api_instance->getDiscoveriesByService(serviceId => $serviceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryApi->getDiscoveriesByService: $@\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.DiscoveryApi()
serviceId = serviceId_example # String |  (default to null)

try:
    api_response = api_instance.get_discoveries_by_service(serviceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryApi->getDiscoveriesByService: %s\n" % e)

extern crate DiscoveryApi;

pub fn main() {
    let serviceId = serviceId_example; // String

    let mut context = DiscoveryApi::Context::default();
    let result = client.getDiscoveriesByService(serviceId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
service_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getDiscoveryByInstance

Get registration of a specified instance

/_/discovery/modules/{service_id}/{instance_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/discovery/modules/{service_id}/{instance_id}"

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();
        String instanceId = instanceId_example; // String | 
        String serviceId = serviceId_example; // String | 

        try {
            DeploymentDescriptor result = apiInstance.getDiscoveryByInstance(instanceId, serviceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getDiscoveryByInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | 
final String serviceId = new String(); // String | 

try {
    final result = await api_instance.getDiscoveryByInstance(instanceId, serviceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getDiscoveryByInstance: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();
        String instanceId = instanceId_example; // String | 
        String serviceId = serviceId_example; // String | 

        try {
            DeploymentDescriptor result = apiInstance.getDiscoveryByInstance(instanceId, serviceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getDiscoveryByInstance");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DiscoveryApi *apiInstance = [[DiscoveryApi alloc] init];
String *instanceId = instanceId_example; //  (default to null)
String *serviceId = serviceId_example; //  (default to null)

[apiInstance getDiscoveryByInstanceWith:instanceId
    serviceId:serviceId
              completionHandler: ^(DeploymentDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.DiscoveryApi()
var instanceId = instanceId_example; // {String} 
var serviceId = serviceId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();
            var instanceId = instanceId_example;  // String |  (default to null)
            var serviceId = serviceId_example;  // String |  (default to null)

            try {
                DeploymentDescriptor result = apiInstance.getDiscoveryByInstance(instanceId, serviceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryApi.getDiscoveryByInstance: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryApi();
$instanceId = instanceId_example; // String | 
$serviceId = serviceId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryApi->new();
my $instanceId = instanceId_example; # String | 
my $serviceId = serviceId_example; # String | 

eval {
    my $result = $api_instance->getDiscoveryByInstance(instanceId => $instanceId, serviceId => $serviceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryApi->getDiscoveryByInstance: $@\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.DiscoveryApi()
instanceId = instanceId_example # String |  (default to null)
serviceId = serviceId_example # String |  (default to null)

try:
    api_response = api_instance.get_discovery_by_instance(instanceId, serviceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryApi->getDiscoveryByInstance: %s\n" % e)

extern crate DiscoveryApi;

pub fn main() {
    let instanceId = instanceId_example; // String
    let serviceId = serviceId_example; // String

    let mut context = DiscoveryApi::Context::default();
    let result = client.getDiscoveryByInstance(instanceId, serviceId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
instance_id*	String Required
service_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getDiscoveryHealthByInstance

Get health for a particular instance

/_/discovery/health/{service_id}/{instance_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/discovery/health/{service_id}/{instance_id}"

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();
        String instanceId = instanceId_example; // String | 
        String serviceId = serviceId_example; // String | 

        try {
            HealthDescriptor result = apiInstance.getDiscoveryHealthByInstance(instanceId, serviceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getDiscoveryHealthByInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | 
final String serviceId = new String(); // String | 

try {
    final result = await api_instance.getDiscoveryHealthByInstance(instanceId, serviceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getDiscoveryHealthByInstance: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();
        String instanceId = instanceId_example; // String | 
        String serviceId = serviceId_example; // String | 

        try {
            HealthDescriptor result = apiInstance.getDiscoveryHealthByInstance(instanceId, serviceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getDiscoveryHealthByInstance");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DiscoveryApi *apiInstance = [[DiscoveryApi alloc] init];
String *instanceId = instanceId_example; //  (default to null)
String *serviceId = serviceId_example; //  (default to null)

[apiInstance getDiscoveryHealthByInstanceWith:instanceId
    serviceId:serviceId
              completionHandler: ^(HealthDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.DiscoveryApi()
var instanceId = instanceId_example; // {String} 
var serviceId = serviceId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();
            var instanceId = instanceId_example;  // String |  (default to null)
            var serviceId = serviceId_example;  // String |  (default to null)

            try {
                HealthDescriptor result = apiInstance.getDiscoveryHealthByInstance(instanceId, serviceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryApi.getDiscoveryHealthByInstance: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryApi();
$instanceId = instanceId_example; // String | 
$serviceId = serviceId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryApi->new();
my $instanceId = instanceId_example; # String | 
my $serviceId = serviceId_example; # String | 

eval {
    my $result = $api_instance->getDiscoveryHealthByInstance(instanceId => $instanceId, serviceId => $serviceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryApi->getDiscoveryHealthByInstance: $@\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.DiscoveryApi()
instanceId = instanceId_example # String |  (default to null)
serviceId = serviceId_example # String |  (default to null)

try:
    api_response = api_instance.get_discovery_health_by_instance(instanceId, serviceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryApi->getDiscoveryHealthByInstance: %s\n" % e)

extern crate DiscoveryApi;

pub fn main() {
    let instanceId = instanceId_example; // String
    let serviceId = serviceId_example; // String

    let mut context = DiscoveryApi::Context::default();
    let result = client.getDiscoveryHealthByInstance(instanceId, serviceId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
instance_id*	String Required
service_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getDiscoveryHealthByService

Health for all instances for a particular service

/_/discovery/health/{service_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/discovery/health/{service_id}"

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();
        String serviceId = serviceId_example; // String | 

        try {
            array[HealthDescriptor] result = apiInstance.getDiscoveryHealthByService(serviceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getDiscoveryHealthByService");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String serviceId = new String(); // String | 

try {
    final result = await api_instance.getDiscoveryHealthByService(serviceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getDiscoveryHealthByService: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();
        String serviceId = serviceId_example; // String | 

        try {
            array[HealthDescriptor] result = apiInstance.getDiscoveryHealthByService(serviceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getDiscoveryHealthByService");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DiscoveryApi *apiInstance = [[DiscoveryApi alloc] init];
String *serviceId = serviceId_example; //  (default to null)

[apiInstance getDiscoveryHealthByServiceWith:serviceId
              completionHandler: ^(array[HealthDescriptor] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.DiscoveryApi()
var serviceId = serviceId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();
            var serviceId = serviceId_example;  // String |  (default to null)

            try {
                array[HealthDescriptor] result = apiInstance.getDiscoveryHealthByService(serviceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryApi.getDiscoveryHealthByService: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryApi();
$serviceId = serviceId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryApi->new();
my $serviceId = serviceId_example; # String | 

eval {
    my $result = $api_instance->getDiscoveryHealthByService(serviceId => $serviceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryApi->getDiscoveryHealthByService: $@\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.DiscoveryApi()
serviceId = serviceId_example # String |  (default to null)

try:
    api_response = api_instance.get_discovery_health_by_service(serviceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryApi->getDiscoveryHealthByService: %s\n" % e)

extern crate DiscoveryApi;

pub fn main() {
    let serviceId = serviceId_example; // String

    let mut context = DiscoveryApi::Context::default();
    let result = client.getDiscoveryHealthByService(serviceId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
service_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getDiscoveryNode

Get info for one node

/_/discovery/nodes/{node_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/discovery/nodes/{node_id}"

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();
        String nodeId = nodeId_example; // String | 

        try {
            NodeDescriptor result = apiInstance.getDiscoveryNode(nodeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getDiscoveryNode");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String nodeId = new String(); // String | 

try {
    final result = await api_instance.getDiscoveryNode(nodeId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getDiscoveryNode: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();
        String nodeId = nodeId_example; // String | 

        try {
            NodeDescriptor result = apiInstance.getDiscoveryNode(nodeId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#getDiscoveryNode");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DiscoveryApi *apiInstance = [[DiscoveryApi alloc] init];
String *nodeId = nodeId_example; //  (default to null)

[apiInstance getDiscoveryNodeWith:nodeId
              completionHandler: ^(NodeDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.DiscoveryApi()
var nodeId = nodeId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();
            var nodeId = nodeId_example;  // String |  (default to null)

            try {
                NodeDescriptor result = apiInstance.getDiscoveryNode(nodeId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryApi.getDiscoveryNode: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryApi();
$nodeId = nodeId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryApi->new();
my $nodeId = nodeId_example; # String | 

eval {
    my $result = $api_instance->getDiscoveryNode(nodeId => $nodeId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryApi->getDiscoveryNode: $@\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.DiscoveryApi()
nodeId = nodeId_example # String |  (default to null)

try:
    api_response = api_instance.get_discovery_node(nodeId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryApi->getDiscoveryNode: %s\n" % e)

extern crate DiscoveryApi;

pub fn main() {
    let nodeId = nodeId_example; // String

    let mut context = DiscoveryApi::Context::default();
    let result = client.getDiscoveryNode(nodeId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
node_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

updateDiscoveryNode

Update descriptor of a particular node, only the name can be changed

/_/discovery/nodes/{node_id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/discovery/nodes/{node_id}" \
 -d '{
  "nodeName" : "nodeName",
  "nodeId" : "nodeId",
  "url" : "url"
}'

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

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

public class DiscoveryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DiscoveryApi apiInstance = new DiscoveryApi();
        String nodeId = nodeId_example; // String | 
        NodeDescriptor nodeDescriptor = ; // NodeDescriptor | 

        try {
            NodeDescriptor result = apiInstance.updateDiscoveryNode(nodeId, nodeDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#updateDiscoveryNode");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String nodeId = new String(); // String | 
final NodeDescriptor nodeDescriptor = new NodeDescriptor(); // NodeDescriptor | 

try {
    final result = await api_instance.updateDiscoveryNode(nodeId, nodeDescriptor);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateDiscoveryNode: $e\n');
}

import org.openapitools.client.api.DiscoveryApi;

public class DiscoveryApiExample {
    public static void main(String[] args) {
        DiscoveryApi apiInstance = new DiscoveryApi();
        String nodeId = nodeId_example; // String | 
        NodeDescriptor nodeDescriptor = ; // NodeDescriptor | 

        try {
            NodeDescriptor result = apiInstance.updateDiscoveryNode(nodeId, nodeDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryApi#updateDiscoveryNode");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DiscoveryApi *apiInstance = [[DiscoveryApi alloc] init];
String *nodeId = nodeId_example; //  (default to null)
NodeDescriptor *nodeDescriptor = ; // 

[apiInstance updateDiscoveryNodeWith:nodeId
    nodeDescriptor:nodeDescriptor
              completionHandler: ^(NodeDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.DiscoveryApi()
var nodeId = nodeId_example; // {String} 
var nodeDescriptor = ; // {NodeDescriptor} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryApi();
            var nodeId = nodeId_example;  // String |  (default to null)
            var nodeDescriptor = new NodeDescriptor(); // NodeDescriptor | 

            try {
                NodeDescriptor result = apiInstance.updateDiscoveryNode(nodeId, nodeDescriptor);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryApi.updateDiscoveryNode: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryApi();
$nodeId = nodeId_example; // String | 
$nodeDescriptor = ; // NodeDescriptor | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryApi->new();
my $nodeId = nodeId_example; # String | 
my $nodeDescriptor = WWW::OPenAPIClient::Object::NodeDescriptor->new(); # NodeDescriptor | 

eval {
    my $result = $api_instance->updateDiscoveryNode(nodeId => $nodeId, nodeDescriptor => $nodeDescriptor);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryApi->updateDiscoveryNode: $@\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.DiscoveryApi()
nodeId = nodeId_example # String |  (default to null)
nodeDescriptor =  # NodeDescriptor | 

try:
    api_response = api_instance.update_discovery_node(nodeId, nodeDescriptor)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryApi->updateDiscoveryNode: %s\n" % e)

extern crate DiscoveryApi;

pub fn main() {
    let nodeId = nodeId_example; // String
    let nodeDescriptor = ; // NodeDescriptor

    let mut context = DiscoveryApi::Context::default();
    let result = client.updateDiscoveryNode(nodeId, nodeDescriptor, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
node_id*	String Required

Body parameters

Name	Description
nodeDescriptor *

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

Environment

createEnvironmentEntry

Add environment entry

/_/env

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/env" \
 -d '{
  "name" : "name",
  "description" : "description",
  "value" : "value"
}'

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

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

public class EnvironmentApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        EnvironmentApi apiInstance = new EnvironmentApi();
        EnvEntry envEntry = ; // EnvEntry | 

        try {
            EnvEntry result = apiInstance.createEnvironmentEntry(envEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentApi#createEnvironmentEntry");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final EnvEntry envEntry = new EnvEntry(); // EnvEntry | 

try {
    final result = await api_instance.createEnvironmentEntry(envEntry);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createEnvironmentEntry: $e\n');
}

import org.openapitools.client.api.EnvironmentApi;

public class EnvironmentApiExample {
    public static void main(String[] args) {
        EnvironmentApi apiInstance = new EnvironmentApi();
        EnvEntry envEntry = ; // EnvEntry | 

        try {
            EnvEntry result = apiInstance.createEnvironmentEntry(envEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentApi#createEnvironmentEntry");
            e.printStackTrace();
        }
    }
}



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

[apiInstance createEnvironmentEntryWith:envEntry
              completionHandler: ^(EnvEntry output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.EnvironmentApi()
var envEntry = ; // {EnvEntry} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new EnvironmentApi();
            var envEntry = new EnvEntry(); // EnvEntry | 

            try {
                EnvEntry result = apiInstance.createEnvironmentEntry(envEntry);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EnvironmentApi.createEnvironmentEntry: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EnvironmentApi();
$envEntry = ; // EnvEntry | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EnvironmentApi->new();
my $envEntry = WWW::OPenAPIClient::Object::EnvEntry->new(); # EnvEntry | 

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

try:
    api_response = api_instance.create_environment_entry(envEntry)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnvironmentApi->createEnvironmentEntry: %s\n" % e)

extern crate EnvironmentApi;

pub fn main() {
    let envEntry = ; // EnvEntry

    let mut context = EnvironmentApi::Context::default();
    let result = client.createEnvironmentEntry(envEntry, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
envEntry *

Responses

Schema
Headers

Name	Type	Format	Description
Location	String		URI to the environment entry instance
X-Okapi-Trace	String

deleteEnvironmentEntry

Remove environment variable

/_/env/{id}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:8081/_/env/{id}"

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

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

public class EnvironmentApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        EnvironmentApi apiInstance = new EnvironmentApi();
        String id = id_example; // String | 

        try {
            apiInstance.deleteEnvironmentEntry(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentApi#deleteEnvironmentEntry");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.deleteEnvironmentEntry(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteEnvironmentEntry: $e\n');
}

import org.openapitools.client.api.EnvironmentApi;

public class EnvironmentApiExample {
    public static void main(String[] args) {
        EnvironmentApi apiInstance = new EnvironmentApi();
        String id = id_example; // String | 

        try {
            apiInstance.deleteEnvironmentEntry(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentApi#deleteEnvironmentEntry");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
EnvironmentApi *apiInstance = [[EnvironmentApi alloc] init];
String *id = id_example; //  (default to null)

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.EnvironmentApi()
var id = id_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new EnvironmentApi();
            var id = id_example;  // String |  (default to null)

            try {
                apiInstance.deleteEnvironmentEntry(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling EnvironmentApi.deleteEnvironmentEntry: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EnvironmentApi();
$id = id_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EnvironmentApi->new();
my $id = id_example; # String | 

eval {
    $api_instance->deleteEnvironmentEntry(id => $id);
};
if ($@) {
    warn "Exception when calling EnvironmentApi->deleteEnvironmentEntry: $@\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.EnvironmentApi()
id = id_example # String |  (default to null)

try:
    api_instance.delete_environment_entry(id)
except ApiException as e:
    print("Exception when calling EnvironmentApi->deleteEnvironmentEntry: %s\n" % e)

extern crate EnvironmentApi;

pub fn main() {
    let id = id_example; // String

    let mut context = EnvironmentApi::Context::default();
    let result = client.deleteEnvironmentEntry(id, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getAllEnvironmentEntries

Get list of all environment variables

/_/env

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/env"

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

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

public class EnvironmentApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        EnvironmentApi apiInstance = new EnvironmentApi();

        try {
            array[EnvEntry] result = apiInstance.getAllEnvironmentEntries();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentApi#getAllEnvironmentEntries");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getAllEnvironmentEntries();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllEnvironmentEntries: $e\n');
}

import org.openapitools.client.api.EnvironmentApi;

public class EnvironmentApiExample {
    public static void main(String[] args) {
        EnvironmentApi apiInstance = new EnvironmentApi();

        try {
            array[EnvEntry] result = apiInstance.getAllEnvironmentEntries();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentApi#getAllEnvironmentEntries");
            e.printStackTrace();
        }
    }
}



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

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

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

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

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

            // Create an instance of the API class
            var apiInstance = new EnvironmentApi();

            try {
                array[EnvEntry] result = apiInstance.getAllEnvironmentEntries();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EnvironmentApi.getAllEnvironmentEntries: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate EnvironmentApi;

pub fn main() {

    let mut context = EnvironmentApi::Context::default();
    let result = client.getAllEnvironmentEntries(&context).wait();

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

Scopes

Parameters

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getEnvironmentEntry

Get info for one environment variable

/_/env/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/env/{id}"

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

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

public class EnvironmentApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        EnvironmentApi apiInstance = new EnvironmentApi();
        String id = id_example; // String | 

        try {
            EnvEntry result = apiInstance.getEnvironmentEntry(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentApi#getEnvironmentEntry");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.getEnvironmentEntry(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getEnvironmentEntry: $e\n');
}

import org.openapitools.client.api.EnvironmentApi;

public class EnvironmentApiExample {
    public static void main(String[] args) {
        EnvironmentApi apiInstance = new EnvironmentApi();
        String id = id_example; // String | 

        try {
            EnvEntry result = apiInstance.getEnvironmentEntry(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentApi#getEnvironmentEntry");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
EnvironmentApi *apiInstance = [[EnvironmentApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance getEnvironmentEntryWith:id
              completionHandler: ^(EnvEntry output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.EnvironmentApi()
var id = id_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new EnvironmentApi();
            var id = id_example;  // String |  (default to null)

            try {
                EnvEntry result = apiInstance.getEnvironmentEntry(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EnvironmentApi.getEnvironmentEntry: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EnvironmentApi();
$id = id_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EnvironmentApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->getEnvironmentEntry(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnvironmentApi->getEnvironmentEntry: $@\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.EnvironmentApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.get_environment_entry(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnvironmentApi->getEnvironmentEntry: %s\n" % e)

extern crate EnvironmentApi;

pub fn main() {
    let id = id_example; // String

    let mut context = EnvironmentApi::Context::default();
    let result = client.getEnvironmentEntry(id, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

InvokeService

invoke

Invoke any service (the rest of the path, any method, any response).

/_/invoke/tenant/{id}

Usage and SDK Samples

curl -X GET \
 "http://localhost:8081/_/invoke/tenant/{id}"

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

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

public class InvokeServiceApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        InvokeServiceApi apiInstance = new InvokeServiceApi();
        String id = id_example; // String | 

        try {
            apiInstance.invoke(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling InvokeServiceApi#invoke");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.invoke(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->invoke: $e\n');
}

import org.openapitools.client.api.InvokeServiceApi;

public class InvokeServiceApiExample {
    public static void main(String[] args) {
        InvokeServiceApi apiInstance = new InvokeServiceApi();
        String id = id_example; // String | 

        try {
            apiInstance.invoke(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling InvokeServiceApi#invoke");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
InvokeServiceApi *apiInstance = [[InvokeServiceApi alloc] init];
String *id = id_example; //  (default to null)

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.InvokeServiceApi()
var id = id_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new InvokeServiceApi();
            var id = id_example;  // String |  (default to null)

            try {
                apiInstance.invoke(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling InvokeServiceApi.invoke: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InvokeServiceApi();
$id = id_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InvokeServiceApi->new();
my $id = id_example; # String | 

eval {
    $api_instance->invoke(id => $id);
};
if ($@) {
    warn "Exception when calling InvokeServiceApi->invoke: $@\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.InvokeServiceApi()
id = id_example # String |  (default to null)

try:
    api_instance.invoke(id)
except ApiException as e:
    print("Exception when calling InvokeServiceApi->invoke: %s\n" % e)

extern crate InvokeServiceApi;

pub fn main() {
    let id = id_example; // String

    let mut context = InvokeServiceApi::Context::default();
    let result = client.invoke(id, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	String Required

Responses

ProxyDescriptor

pullDescriptors

Pull modules (i.e. Module Descriptors) from a remote repository. The PullDescriptor includes one or more URLs. And the operation will try all URLs in order until one succeeds. Hence, the URLs should be pointing to identical remote repositories.

/_/proxy/pull/modules

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/proxy/pull/modules" \
 -d '{
  "urls" : [ "urls", "urls" ]
}'

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

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

public class ProxyDescriptorApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyDescriptorApi apiInstance = new ProxyDescriptorApi();
        PullDescriptor pullDescriptor = ; // PullDescriptor | 

        try {
            array[ModuleDescriptor] result = apiInstance.pullDescriptors(pullDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyDescriptorApi#pullDescriptors");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PullDescriptor pullDescriptor = new PullDescriptor(); // PullDescriptor | 

try {
    final result = await api_instance.pullDescriptors(pullDescriptor);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->pullDescriptors: $e\n');
}

import org.openapitools.client.api.ProxyDescriptorApi;

public class ProxyDescriptorApiExample {
    public static void main(String[] args) {
        ProxyDescriptorApi apiInstance = new ProxyDescriptorApi();
        PullDescriptor pullDescriptor = ; // PullDescriptor | 

        try {
            array[ModuleDescriptor] result = apiInstance.pullDescriptors(pullDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyDescriptorApi#pullDescriptors");
            e.printStackTrace();
        }
    }
}



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

[apiInstance pullDescriptorsWith:pullDescriptor
              completionHandler: ^(array[ModuleDescriptor] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyDescriptorApi()
var pullDescriptor = ; // {PullDescriptor} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyDescriptorApi();
            var pullDescriptor = new PullDescriptor(); // PullDescriptor | 

            try {
                array[ModuleDescriptor] result = apiInstance.pullDescriptors(pullDescriptor);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyDescriptorApi.pullDescriptors: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyDescriptorApi();
$pullDescriptor = ; // PullDescriptor | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyDescriptorApi->new();
my $pullDescriptor = WWW::OPenAPIClient::Object::PullDescriptor->new(); # PullDescriptor | 

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

try:
    api_response = api_instance.pull_descriptors(pullDescriptor)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyDescriptorApi->pullDescriptors: %s\n" % e)

extern crate ProxyDescriptorApi;

pub fn main() {
    let pullDescriptor = ; // PullDescriptor

    let mut context = ProxyDescriptorApi::Context::default();
    let result = client.pullDescriptors(pullDescriptor, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
pullDescriptor *

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

ProxyHealth

getHealthStatus

Check health of modules

/_/proxy/health

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/health"

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

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

public class ProxyHealthApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyHealthApi apiInstance = new ProxyHealthApi();

        try {
            array[HealthStatus] result = apiInstance.getHealthStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyHealthApi#getHealthStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getHealthStatus();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getHealthStatus: $e\n');
}

import org.openapitools.client.api.ProxyHealthApi;

public class ProxyHealthApiExample {
    public static void main(String[] args) {
        ProxyHealthApi apiInstance = new ProxyHealthApi();

        try {
            array[HealthStatus] result = apiInstance.getHealthStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyHealthApi#getHealthStatus");
            e.printStackTrace();
        }
    }
}



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

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyHealthApi();

            try {
                array[HealthStatus] result = apiInstance.getHealthStatus();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyHealthApi.getHealthStatus: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate ProxyHealthApi;

pub fn main() {

    let mut context = ProxyHealthApi::Context::default();
    let result = client.getHealthStatus(&context).wait();

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

Scopes

Parameters

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

ProxyModule

announceModule

Announce new module to the proxy. Once successful a module can be selected for a specific tenant.

/_/proxy/modules

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/proxy/modules?check=true&preRelease=preRelease_example&npmSnapshot=npmSnapshot_example" \
 -d '{
  "metadata" : "{}",
  "replaces" : [ "replaces", "replaces" ],
  "permissionSets" : [ null, null ],
  "optional" : [ null, null ],
  "filters" : [ {
    "phase" : "phase",
    "permissionsDesired" : [ "permissionsDesired", "permissionsDesired" ],
    "delegateCORS" : true,
    "level" : "level",
    "methods" : [ "methods", "methods" ],
    "modulePermissions" : [ "modulePermissions", "modulePermissions" ],
    "redirectPath" : "redirectPath",
    "type" : "type",
    "rewritePath" : "rewritePath",
    "permissionsRequired" : [ "permissionsRequired", "permissionsRequired" ],
    "path" : "path",
    "schedule" : {
      "cron" : "cron",
      "zone" : "zone"
    },
    "unit" : "unit",
    "permissionsRequiredTenant" : [ "permissionsRequiredTenant", "permissionsRequiredTenant" ],
    "delay" : "delay",
    "pathPattern" : "pathPattern"
  }, {
    "phase" : "phase",
    "permissionsDesired" : [ "permissionsDesired", "permissionsDesired" ],
    "delegateCORS" : true,
    "level" : "level",
    "methods" : [ "methods", "methods" ],
    "modulePermissions" : [ "modulePermissions", "modulePermissions" ],
    "redirectPath" : "redirectPath",
    "type" : "type",
    "rewritePath" : "rewritePath",
    "permissionsRequired" : [ "permissionsRequired", "permissionsRequired" ],
    "path" : "path",
    "schedule" : {
      "cron" : "cron",
      "zone" : "zone"
    },
    "unit" : "unit",
    "permissionsRequiredTenant" : [ "permissionsRequiredTenant", "permissionsRequiredTenant" ],
    "delay" : "delay",
    "pathPattern" : "pathPattern"
  } ],
  "launchDescriptor" : "{}",
  "env" : [ {
    "name" : "name",
    "description" : "description",
    "value" : "value"
  }, {
    "name" : "name",
    "description" : "description",
    "value" : "value"
  } ],
  "tags" : [ "tags", "tags" ],
  "provides" : [ null, null ],
  "uiDescriptor" : "{}",
  "name" : "name",
  "id" : "id",
  "requires" : [ null, null ]
}'

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

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

public class ProxyModuleApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyModuleApi apiInstance = new ProxyModuleApi();
        ModuleDescriptor moduleDescriptor = ; // ModuleDescriptor | 
        Boolean check = true; // Boolean | Whether to check dependencies
        String preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
        String npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

        try {
            ModuleDescriptor result = apiInstance.announceModule(moduleDescriptor, check, preRelease, npmSnapshot);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyModuleApi#announceModule");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ModuleDescriptor moduleDescriptor = new ModuleDescriptor(); // ModuleDescriptor | 
final Boolean check = new Boolean(); // Boolean | Whether to check dependencies
final String preRelease = new String(); // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
final String npmSnapshot = new String(); // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

try {
    final result = await api_instance.announceModule(moduleDescriptor, check, preRelease, npmSnapshot);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->announceModule: $e\n');
}

import org.openapitools.client.api.ProxyModuleApi;

public class ProxyModuleApiExample {
    public static void main(String[] args) {
        ProxyModuleApi apiInstance = new ProxyModuleApi();
        ModuleDescriptor moduleDescriptor = ; // ModuleDescriptor | 
        Boolean check = true; // Boolean | Whether to check dependencies
        String preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
        String npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

        try {
            ModuleDescriptor result = apiInstance.announceModule(moduleDescriptor, check, preRelease, npmSnapshot);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyModuleApi#announceModule");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyModuleApi *apiInstance = [[ProxyModuleApi alloc] init];
ModuleDescriptor *moduleDescriptor = ; // 
Boolean *check = true; // Whether to check dependencies (optional) (default to true)
String *preRelease = preRelease_example; // Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional) (default to true)
String *npmSnapshot = npmSnapshot_example; // Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional) (default to true)

[apiInstance announceModuleWith:moduleDescriptor
    check:check
    preRelease:preRelease
    npmSnapshot:npmSnapshot
              completionHandler: ^(ModuleDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyModuleApi()
var moduleDescriptor = ; // {ModuleDescriptor} 
var opts = {
  'check': true, // {Boolean} Whether to check dependencies
  'preRelease': preRelease_example, // {String} Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
  'npmSnapshot': npmSnapshot_example // {String} Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyModuleApi();
            var moduleDescriptor = new ModuleDescriptor(); // ModuleDescriptor | 
            var check = true;  // Boolean | Whether to check dependencies (optional)  (default to true)
            var preRelease = preRelease_example;  // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional)  (default to true)
            var npmSnapshot = npmSnapshot_example;  // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional)  (default to true)

            try {
                ModuleDescriptor result = apiInstance.announceModule(moduleDescriptor, check, preRelease, npmSnapshot);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyModuleApi.announceModule: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyModuleApi();
$moduleDescriptor = ; // ModuleDescriptor | 
$check = true; // Boolean | Whether to check dependencies
$preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
$npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

try {
    $result = $api_instance->announceModule($moduleDescriptor, $check, $preRelease, $npmSnapshot);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyModuleApi->announceModule: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyModuleApi->new();
my $moduleDescriptor = WWW::OPenAPIClient::Object::ModuleDescriptor->new(); # ModuleDescriptor | 
my $check = true; # Boolean | Whether to check dependencies
my $preRelease = preRelease_example; # String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
my $npmSnapshot = npmSnapshot_example; # String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

eval {
    my $result = $api_instance->announceModule(moduleDescriptor => $moduleDescriptor, check => $check, preRelease => $preRelease, npmSnapshot => $npmSnapshot);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyModuleApi->announceModule: $@\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.ProxyModuleApi()
moduleDescriptor =  # ModuleDescriptor | 
check = true # Boolean | Whether to check dependencies (optional) (default to true)
preRelease = preRelease_example # String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional) (default to true)
npmSnapshot = npmSnapshot_example # String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional) (default to true)

try:
    api_response = api_instance.announce_module(moduleDescriptor, check=check, preRelease=preRelease, npmSnapshot=npmSnapshot)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyModuleApi->announceModule: %s\n" % e)

extern crate ProxyModuleApi;

pub fn main() {
    let moduleDescriptor = ; // ModuleDescriptor
    let check = true; // Boolean
    let preRelease = preRelease_example; // String
    let npmSnapshot = npmSnapshot_example; // String

    let mut context = ProxyModuleApi::Context::default();
    let result = client.announceModule(moduleDescriptor, check, preRelease, npmSnapshot, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
moduleDescriptor *

Query parameters

Name	Description
check	Boolean Whether to check dependencies
preRelease	String Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
npmSnapshot	String Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String
Location	String		URI to the environment entry instance

announceModules

Announce a list of new modules to the proxy. Once successful a module can be selected for a specific tenant. To announce only one module you may use /_/proxy/modules.

/_/proxy/import/modules

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/proxy/import/modules?check=true&preRelease=preRelease_example&npmSnapshot=npmSnapshot_example" \
 -d '{
  "metadata" : "{}",
  "replaces" : [ "replaces", "replaces" ],
  "permissionSets" : [ null, null ],
  "optional" : [ null, null ],
  "filters" : [ {
    "phase" : "phase",
    "permissionsDesired" : [ "permissionsDesired", "permissionsDesired" ],
    "delegateCORS" : true,
    "level" : "level",
    "methods" : [ "methods", "methods" ],
    "modulePermissions" : [ "modulePermissions", "modulePermissions" ],
    "redirectPath" : "redirectPath",
    "type" : "type",
    "rewritePath" : "rewritePath",
    "permissionsRequired" : [ "permissionsRequired", "permissionsRequired" ],
    "path" : "path",
    "schedule" : {
      "cron" : "cron",
      "zone" : "zone"
    },
    "unit" : "unit",
    "permissionsRequiredTenant" : [ "permissionsRequiredTenant", "permissionsRequiredTenant" ],
    "delay" : "delay",
    "pathPattern" : "pathPattern"
  }, {
    "phase" : "phase",
    "permissionsDesired" : [ "permissionsDesired", "permissionsDesired" ],
    "delegateCORS" : true,
    "level" : "level",
    "methods" : [ "methods", "methods" ],
    "modulePermissions" : [ "modulePermissions", "modulePermissions" ],
    "redirectPath" : "redirectPath",
    "type" : "type",
    "rewritePath" : "rewritePath",
    "permissionsRequired" : [ "permissionsRequired", "permissionsRequired" ],
    "path" : "path",
    "schedule" : {
      "cron" : "cron",
      "zone" : "zone"
    },
    "unit" : "unit",
    "permissionsRequiredTenant" : [ "permissionsRequiredTenant", "permissionsRequiredTenant" ],
    "delay" : "delay",
    "pathPattern" : "pathPattern"
  } ],
  "launchDescriptor" : "{}",
  "env" : [ {
    "name" : "name",
    "description" : "description",
    "value" : "value"
  }, {
    "name" : "name",
    "description" : "description",
    "value" : "value"
  } ],
  "tags" : [ "tags", "tags" ],
  "provides" : [ null, null ],
  "uiDescriptor" : "{}",
  "name" : "name",
  "id" : "id",
  "requires" : [ null, null ]
}'

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

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

public class ProxyModuleApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyModuleApi apiInstance = new ProxyModuleApi();
        array[ModuleDescriptor] moduleDescriptor = ; // array[ModuleDescriptor] | 
        Boolean check = true; // Boolean | Whether to check dependencies
        String preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
        String npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

        try {
            apiInstance.announceModules(moduleDescriptor, check, preRelease, npmSnapshot);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyModuleApi#announceModules");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[ModuleDescriptor] moduleDescriptor = new array[ModuleDescriptor](); // array[ModuleDescriptor] | 
final Boolean check = new Boolean(); // Boolean | Whether to check dependencies
final String preRelease = new String(); // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
final String npmSnapshot = new String(); // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

try {
    final result = await api_instance.announceModules(moduleDescriptor, check, preRelease, npmSnapshot);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->announceModules: $e\n');
}

import org.openapitools.client.api.ProxyModuleApi;

public class ProxyModuleApiExample {
    public static void main(String[] args) {
        ProxyModuleApi apiInstance = new ProxyModuleApi();
        array[ModuleDescriptor] moduleDescriptor = ; // array[ModuleDescriptor] | 
        Boolean check = true; // Boolean | Whether to check dependencies
        String preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
        String npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

        try {
            apiInstance.announceModules(moduleDescriptor, check, preRelease, npmSnapshot);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyModuleApi#announceModules");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyModuleApi *apiInstance = [[ProxyModuleApi alloc] init];
array[ModuleDescriptor] *moduleDescriptor = ; // 
Boolean *check = true; // Whether to check dependencies (optional) (default to true)
String *preRelease = preRelease_example; // Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional) (default to true)
String *npmSnapshot = npmSnapshot_example; // Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional) (default to true)

[apiInstance announceModulesWith:moduleDescriptor
    check:check
    preRelease:preRelease
    npmSnapshot:npmSnapshot
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyModuleApi()
var moduleDescriptor = ; // {array[ModuleDescriptor]} 
var opts = {
  'check': true, // {Boolean} Whether to check dependencies
  'preRelease': preRelease_example, // {String} Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
  'npmSnapshot': npmSnapshot_example // {String} Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyModuleApi();
            var moduleDescriptor = new array[ModuleDescriptor](); // array[ModuleDescriptor] | 
            var check = true;  // Boolean | Whether to check dependencies (optional)  (default to true)
            var preRelease = preRelease_example;  // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional)  (default to true)
            var npmSnapshot = npmSnapshot_example;  // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional)  (default to true)

            try {
                apiInstance.announceModules(moduleDescriptor, check, preRelease, npmSnapshot);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyModuleApi.announceModules: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyModuleApi();
$moduleDescriptor = ; // array[ModuleDescriptor] | 
$check = true; // Boolean | Whether to check dependencies
$preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
$npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

try {
    $api_instance->announceModules($moduleDescriptor, $check, $preRelease, $npmSnapshot);
} catch (Exception $e) {
    echo 'Exception when calling ProxyModuleApi->announceModules: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyModuleApi->new();
my $moduleDescriptor = [WWW::OPenAPIClient::Object::array[ModuleDescriptor]->new()]; # array[ModuleDescriptor] | 
my $check = true; # Boolean | Whether to check dependencies
my $preRelease = preRelease_example; # String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
my $npmSnapshot = npmSnapshot_example; # String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

eval {
    $api_instance->announceModules(moduleDescriptor => $moduleDescriptor, check => $check, preRelease => $preRelease, npmSnapshot => $npmSnapshot);
};
if ($@) {
    warn "Exception when calling ProxyModuleApi->announceModules: $@\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.ProxyModuleApi()
moduleDescriptor =  # array[ModuleDescriptor] | 
check = true # Boolean | Whether to check dependencies (optional) (default to true)
preRelease = preRelease_example # String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional) (default to true)
npmSnapshot = npmSnapshot_example # String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional) (default to true)

try:
    api_instance.announce_modules(moduleDescriptor, check=check, preRelease=preRelease, npmSnapshot=npmSnapshot)
except ApiException as e:
    print("Exception when calling ProxyModuleApi->announceModules: %s\n" % e)

extern crate ProxyModuleApi;

pub fn main() {
    let moduleDescriptor = ; // array[ModuleDescriptor]
    let check = true; // Boolean
    let preRelease = preRelease_example; // String
    let npmSnapshot = npmSnapshot_example; // String

    let mut context = ProxyModuleApi::Context::default();
    let result = client.announceModules(moduleDescriptor, check, preRelease, npmSnapshot, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
moduleDescriptor *

Query parameters

Name	Description
check	Boolean Whether to check dependencies
preRelease	String Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
npmSnapshot	String Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

cleanupModules

Remove module snapshot modules descriptors that are obsolete. A module is considered obsolete if it is part of a release that is earlier than N latest releases (saveReleases) and not part of the M latest snapshots in that release.

/_/proxy/cleanup/modules

Usage and SDK Samples

curl -X POST \
 "http://localhost:8081/_/proxy/cleanup/modules?removeDependencies=true&saveReleases=56&saveSnapshots=56"

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

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

public class ProxyModuleApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyModuleApi apiInstance = new ProxyModuleApi();
        Integer saveReleases = 56; // Integer | The number of latest releases where snapshots are never considered obsolete
        Integer saveSnapshots = 56; // Integer | The number of latest snapshots that are never considered obsolete (preserved)
        Boolean removeDependencies = true; // Boolean | Force removal of modules that depend on obsolete snapshots

        try {
            apiInstance.cleanupModules(saveReleases, saveSnapshots, removeDependencies);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyModuleApi#cleanupModules");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer saveReleases = new Integer(); // Integer | The number of latest releases where snapshots are never considered obsolete
final Integer saveSnapshots = new Integer(); // Integer | The number of latest snapshots that are never considered obsolete (preserved)
final Boolean removeDependencies = new Boolean(); // Boolean | Force removal of modules that depend on obsolete snapshots

try {
    final result = await api_instance.cleanupModules(saveReleases, saveSnapshots, removeDependencies);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->cleanupModules: $e\n');
}

import org.openapitools.client.api.ProxyModuleApi;

public class ProxyModuleApiExample {
    public static void main(String[] args) {
        ProxyModuleApi apiInstance = new ProxyModuleApi();
        Integer saveReleases = 56; // Integer | The number of latest releases where snapshots are never considered obsolete
        Integer saveSnapshots = 56; // Integer | The number of latest snapshots that are never considered obsolete (preserved)
        Boolean removeDependencies = true; // Boolean | Force removal of modules that depend on obsolete snapshots

        try {
            apiInstance.cleanupModules(saveReleases, saveSnapshots, removeDependencies);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyModuleApi#cleanupModules");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyModuleApi *apiInstance = [[ProxyModuleApi alloc] init];
Integer *saveReleases = 56; // The number of latest releases where snapshots are never considered obsolete (default to null)
Integer *saveSnapshots = 56; // The number of latest snapshots that are never considered obsolete (preserved) (default to null)
Boolean *removeDependencies = true; // Force removal of modules that depend on obsolete snapshots (optional) (default to false)

[apiInstance cleanupModulesWith:saveReleases
    saveSnapshots:saveSnapshots
    removeDependencies:removeDependencies
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyModuleApi()
var saveReleases = 56; // {Integer} The number of latest releases where snapshots are never considered obsolete
var saveSnapshots = 56; // {Integer} The number of latest snapshots that are never considered obsolete (preserved)
var opts = {
  'removeDependencies': true // {Boolean} Force removal of modules that depend on obsolete snapshots
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyModuleApi();
            var saveReleases = 56;  // Integer | The number of latest releases where snapshots are never considered obsolete (default to null)
            var saveSnapshots = 56;  // Integer | The number of latest snapshots that are never considered obsolete (preserved) (default to null)
            var removeDependencies = true;  // Boolean | Force removal of modules that depend on obsolete snapshots (optional)  (default to false)

            try {
                apiInstance.cleanupModules(saveReleases, saveSnapshots, removeDependencies);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyModuleApi.cleanupModules: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyModuleApi();
$saveReleases = 56; // Integer | The number of latest releases where snapshots are never considered obsolete
$saveSnapshots = 56; // Integer | The number of latest snapshots that are never considered obsolete (preserved)
$removeDependencies = true; // Boolean | Force removal of modules that depend on obsolete snapshots

try {
    $api_instance->cleanupModules($saveReleases, $saveSnapshots, $removeDependencies);
} catch (Exception $e) {
    echo 'Exception when calling ProxyModuleApi->cleanupModules: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyModuleApi->new();
my $saveReleases = 56; # Integer | The number of latest releases where snapshots are never considered obsolete
my $saveSnapshots = 56; # Integer | The number of latest snapshots that are never considered obsolete (preserved)
my $removeDependencies = true; # Boolean | Force removal of modules that depend on obsolete snapshots

eval {
    $api_instance->cleanupModules(saveReleases => $saveReleases, saveSnapshots => $saveSnapshots, removeDependencies => $removeDependencies);
};
if ($@) {
    warn "Exception when calling ProxyModuleApi->cleanupModules: $@\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.ProxyModuleApi()
saveReleases = 56 # Integer | The number of latest releases where snapshots are never considered obsolete (default to null)
saveSnapshots = 56 # Integer | The number of latest snapshots that are never considered obsolete (preserved) (default to null)
removeDependencies = true # Boolean | Force removal of modules that depend on obsolete snapshots (optional) (default to false)

try:
    api_instance.cleanup_modules(saveReleases, saveSnapshots, removeDependencies=removeDependencies)
except ApiException as e:
    print("Exception when calling ProxyModuleApi->cleanupModules: %s\n" % e)

extern crate ProxyModuleApi;

pub fn main() {
    let saveReleases = 56; // Integer
    let saveSnapshots = 56; // Integer
    let removeDependencies = true; // Boolean

    let mut context = ProxyModuleApi::Context::default();
    let result = client.cleanupModules(saveReleases, saveSnapshots, removeDependencies, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
removeDependencies	Boolean Force removal of modules that depend on obsolete snapshots
saveReleases*	Integer The number of latest releases where snapshots are never considered obsolete Required
saveSnapshots*	Integer The number of latest snapshots that are never considered obsolete (preserved) Required

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

deleteModule

Remove module descriptor for a particular module, module will no longer be selectable by tenants

/_/proxy/modules/{module_id}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:8081/_/proxy/modules/{module_id}"

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

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

public class ProxyModuleApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyModuleApi apiInstance = new ProxyModuleApi();
        String moduleId = moduleId_example; // String | 

        try {
            apiInstance.deleteModule(moduleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyModuleApi#deleteModule");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String moduleId = new String(); // String | 

try {
    final result = await api_instance.deleteModule(moduleId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteModule: $e\n');
}

import org.openapitools.client.api.ProxyModuleApi;

public class ProxyModuleApiExample {
    public static void main(String[] args) {
        ProxyModuleApi apiInstance = new ProxyModuleApi();
        String moduleId = moduleId_example; // String | 

        try {
            apiInstance.deleteModule(moduleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyModuleApi#deleteModule");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyModuleApi *apiInstance = [[ProxyModuleApi alloc] init];
String *moduleId = moduleId_example; //  (default to null)

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyModuleApi()
var moduleId = moduleId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyModuleApi();
            var moduleId = moduleId_example;  // String |  (default to null)

            try {
                apiInstance.deleteModule(moduleId);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyModuleApi.deleteModule: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyModuleApi();
$moduleId = moduleId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyModuleApi->new();
my $moduleId = moduleId_example; # String | 

eval {
    $api_instance->deleteModule(moduleId => $moduleId);
};
if ($@) {
    warn "Exception when calling ProxyModuleApi->deleteModule: $@\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.ProxyModuleApi()
moduleId = moduleId_example # String |  (default to null)

try:
    api_instance.delete_module(moduleId)
except ApiException as e:
    print("Exception when calling ProxyModuleApi->deleteModule: %s\n" % e)

extern crate ProxyModuleApi;

pub fn main() {
    let moduleId = moduleId_example; // String

    let mut context = ProxyModuleApi::Context::default();
    let result = client.deleteModule(moduleId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
module_id*	String Required

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getAllModules

List all or subset of modules for proxy

/_/proxy/modules

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/modules?dot=true&filter=filter_example&full=true&latest=56&order=order_example&orderBy=orderBy_example&provide=provide_example&require=require_example&scope=scope_example&preRelease=preRelease_example&npmSnapshot=npmSnapshot_example"

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

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

public class ProxyModuleApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyModuleApi apiInstance = new ProxyModuleApi();
        Boolean dot = true; // Boolean | If true, return Graphviz DOT content as plain text
        String filter = filter_example; // String | Filter by module ID
        Boolean full = true; // Boolean | Whether full or compact MD should be returned
        Integer latest = 56; // Integer | Limit to latest N releases (most likely 1 if given)
        String order = order_example; // String | Order
        String orderBy = orderBy_example; // String | Order by field
        String provide = provide_example; // String | Limit to provided interfaces (each interface name separated by comma)
        String require = require_example; // String | Limit to required interfaces (each interface name separated by comma)
        String scope = scope_example; // String | Limit to interface scope (only useful with provide and require)
        String preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
        String npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

        try {
            array[ModuleDescriptor] result = apiInstance.getAllModules(dot, filter, full, latest, order, orderBy, provide, require, scope, preRelease, npmSnapshot);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyModuleApi#getAllModules");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Boolean dot = new Boolean(); // Boolean | If true, return Graphviz DOT content as plain text
final String filter = new String(); // String | Filter by module ID
final Boolean full = new Boolean(); // Boolean | Whether full or compact MD should be returned
final Integer latest = new Integer(); // Integer | Limit to latest N releases (most likely 1 if given)
final String order = new String(); // String | Order
final String orderBy = new String(); // String | Order by field
final String provide = new String(); // String | Limit to provided interfaces (each interface name separated by comma)
final String require = new String(); // String | Limit to required interfaces (each interface name separated by comma)
final String scope = new String(); // String | Limit to interface scope (only useful with provide and require)
final String preRelease = new String(); // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
final String npmSnapshot = new String(); // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

try {
    final result = await api_instance.getAllModules(dot, filter, full, latest, order, orderBy, provide, require, scope, preRelease, npmSnapshot);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllModules: $e\n');
}

import org.openapitools.client.api.ProxyModuleApi;

public class ProxyModuleApiExample {
    public static void main(String[] args) {
        ProxyModuleApi apiInstance = new ProxyModuleApi();
        Boolean dot = true; // Boolean | If true, return Graphviz DOT content as plain text
        String filter = filter_example; // String | Filter by module ID
        Boolean full = true; // Boolean | Whether full or compact MD should be returned
        Integer latest = 56; // Integer | Limit to latest N releases (most likely 1 if given)
        String order = order_example; // String | Order
        String orderBy = orderBy_example; // String | Order by field
        String provide = provide_example; // String | Limit to provided interfaces (each interface name separated by comma)
        String require = require_example; // String | Limit to required interfaces (each interface name separated by comma)
        String scope = scope_example; // String | Limit to interface scope (only useful with provide and require)
        String preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
        String npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

        try {
            array[ModuleDescriptor] result = apiInstance.getAllModules(dot, filter, full, latest, order, orderBy, provide, require, scope, preRelease, npmSnapshot);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyModuleApi#getAllModules");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyModuleApi *apiInstance = [[ProxyModuleApi alloc] init];
Boolean *dot = true; // If true, return Graphviz DOT content as plain text (optional) (default to false)
String *filter = filter_example; // Filter by module ID (optional) (default to null)
Boolean *full = true; // Whether full or compact MD should be returned (optional) (default to false)
Integer *latest = 56; // Limit to latest N releases (most likely 1 if given) (optional) (default to null)
String *order = order_example; // Order (optional) (default to null)
String *orderBy = orderBy_example; // Order by field (optional) (default to null)
String *provide = provide_example; // Limit to provided interfaces (each interface name separated by comma) (optional) (default to null)
String *require = require_example; // Limit to required interfaces (each interface name separated by comma) (optional) (default to null)
String *scope = scope_example; // Limit to interface scope (only useful with provide and require) (optional) (default to null)
String *preRelease = preRelease_example; // Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional) (default to true)
String *npmSnapshot = npmSnapshot_example; // Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional) (default to true)

[apiInstance getAllModulesWith:dot
    filter:filter
    full:full
    latest:latest
    order:order
    orderBy:orderBy
    provide:provide
    require:require
    scope:scope
    preRelease:preRelease
    npmSnapshot:npmSnapshot
              completionHandler: ^(array[ModuleDescriptor] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyModuleApi()
var opts = {
  'dot': true, // {Boolean} If true, return Graphviz DOT content as plain text
  'filter': filter_example, // {String} Filter by module ID
  'full': true, // {Boolean} Whether full or compact MD should be returned
  'latest': 56, // {Integer} Limit to latest N releases (most likely 1 if given)
  'order': order_example, // {String} Order
  'orderBy': orderBy_example, // {String} Order by field
  'provide': provide_example, // {String} Limit to provided interfaces (each interface name separated by comma)
  'require': require_example, // {String} Limit to required interfaces (each interface name separated by comma)
  'scope': scope_example, // {String} Limit to interface scope (only useful with provide and require)
  'preRelease': preRelease_example, // {String} Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
  'npmSnapshot': npmSnapshot_example // {String} Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyModuleApi();
            var dot = true;  // Boolean | If true, return Graphviz DOT content as plain text (optional)  (default to false)
            var filter = filter_example;  // String | Filter by module ID (optional)  (default to null)
            var full = true;  // Boolean | Whether full or compact MD should be returned (optional)  (default to false)
            var latest = 56;  // Integer | Limit to latest N releases (most likely 1 if given) (optional)  (default to null)
            var order = order_example;  // String | Order (optional)  (default to null)
            var orderBy = orderBy_example;  // String | Order by field (optional)  (default to null)
            var provide = provide_example;  // String | Limit to provided interfaces (each interface name separated by comma) (optional)  (default to null)
            var require = require_example;  // String | Limit to required interfaces (each interface name separated by comma) (optional)  (default to null)
            var scope = scope_example;  // String | Limit to interface scope (only useful with provide and require) (optional)  (default to null)
            var preRelease = preRelease_example;  // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional)  (default to true)
            var npmSnapshot = npmSnapshot_example;  // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional)  (default to true)

            try {
                array[ModuleDescriptor] result = apiInstance.getAllModules(dot, filter, full, latest, order, orderBy, provide, require, scope, preRelease, npmSnapshot);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyModuleApi.getAllModules: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyModuleApi();
$dot = true; // Boolean | If true, return Graphviz DOT content as plain text
$filter = filter_example; // String | Filter by module ID
$full = true; // Boolean | Whether full or compact MD should be returned
$latest = 56; // Integer | Limit to latest N releases (most likely 1 if given)
$order = order_example; // String | Order
$orderBy = orderBy_example; // String | Order by field
$provide = provide_example; // String | Limit to provided interfaces (each interface name separated by comma)
$require = require_example; // String | Limit to required interfaces (each interface name separated by comma)
$scope = scope_example; // String | Limit to interface scope (only useful with provide and require)
$preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
$npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

try {
    $result = $api_instance->getAllModules($dot, $filter, $full, $latest, $order, $orderBy, $provide, $require, $scope, $preRelease, $npmSnapshot);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyModuleApi->getAllModules: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyModuleApi->new();
my $dot = true; # Boolean | If true, return Graphviz DOT content as plain text
my $filter = filter_example; # String | Filter by module ID
my $full = true; # Boolean | Whether full or compact MD should be returned
my $latest = 56; # Integer | Limit to latest N releases (most likely 1 if given)
my $order = order_example; # String | Order
my $orderBy = orderBy_example; # String | Order by field
my $provide = provide_example; # String | Limit to provided interfaces (each interface name separated by comma)
my $require = require_example; # String | Limit to required interfaces (each interface name separated by comma)
my $scope = scope_example; # String | Limit to interface scope (only useful with provide and require)
my $preRelease = preRelease_example; # String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
my $npmSnapshot = npmSnapshot_example; # String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

eval {
    my $result = $api_instance->getAllModules(dot => $dot, filter => $filter, full => $full, latest => $latest, order => $order, orderBy => $orderBy, provide => $provide, require => $require, scope => $scope, preRelease => $preRelease, npmSnapshot => $npmSnapshot);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyModuleApi->getAllModules: $@\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.ProxyModuleApi()
dot = true # Boolean | If true, return Graphviz DOT content as plain text (optional) (default to false)
filter = filter_example # String | Filter by module ID (optional) (default to null)
full = true # Boolean | Whether full or compact MD should be returned (optional) (default to false)
latest = 56 # Integer | Limit to latest N releases (most likely 1 if given) (optional) (default to null)
order = order_example # String | Order (optional) (default to null)
orderBy = orderBy_example # String | Order by field (optional) (default to null)
provide = provide_example # String | Limit to provided interfaces (each interface name separated by comma) (optional) (default to null)
require = require_example # String | Limit to required interfaces (each interface name separated by comma) (optional) (default to null)
scope = scope_example # String | Limit to interface scope (only useful with provide and require) (optional) (default to null)
preRelease = preRelease_example # String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional) (default to true)
npmSnapshot = npmSnapshot_example # String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional) (default to true)

try:
    api_response = api_instance.get_all_modules(dot=dot, filter=filter, full=full, latest=latest, order=order, orderBy=orderBy, provide=provide, require=require, scope=scope, preRelease=preRelease, npmSnapshot=npmSnapshot)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyModuleApi->getAllModules: %s\n" % e)

extern crate ProxyModuleApi;

pub fn main() {
    let dot = true; // Boolean
    let filter = filter_example; // String
    let full = true; // Boolean
    let latest = 56; // Integer
    let order = order_example; // String
    let orderBy = orderBy_example; // String
    let provide = provide_example; // String
    let require = require_example; // String
    let scope = scope_example; // String
    let preRelease = preRelease_example; // String
    let npmSnapshot = npmSnapshot_example; // String

    let mut context = ProxyModuleApi::Context::default();
    let result = client.getAllModules(dot, filter, full, latest, order, orderBy, provide, require, scope, preRelease, npmSnapshot, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
dot	Boolean If true, return Graphviz DOT content as plain text
filter	String Filter by module ID
full	Boolean Whether full or compact MD should be returned
latest	Integer Limit to latest N releases (most likely 1 if given)
order	String Order
orderBy	String Order by field
provide	String Limit to provided interfaces (each interface name separated by comma)
require	String Limit to required interfaces (each interface name separated by comma)
scope	String Limit to interface scope (only useful with provide and require)
preRelease	String Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
npmSnapshot	String Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getModule

Retrieve descriptor for a particular module

/_/proxy/modules/{module_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/modules/{module_id}"

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

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

public class ProxyModuleApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyModuleApi apiInstance = new ProxyModuleApi();
        String moduleId = moduleId_example; // String | 

        try {
            ModuleDescriptor result = apiInstance.getModule(moduleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyModuleApi#getModule");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String moduleId = new String(); // String | 

try {
    final result = await api_instance.getModule(moduleId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getModule: $e\n');
}

import org.openapitools.client.api.ProxyModuleApi;

public class ProxyModuleApiExample {
    public static void main(String[] args) {
        ProxyModuleApi apiInstance = new ProxyModuleApi();
        String moduleId = moduleId_example; // String | 

        try {
            ModuleDescriptor result = apiInstance.getModule(moduleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyModuleApi#getModule");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyModuleApi *apiInstance = [[ProxyModuleApi alloc] init];
String *moduleId = moduleId_example; //  (default to null)

[apiInstance getModuleWith:moduleId
              completionHandler: ^(ModuleDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyModuleApi()
var moduleId = moduleId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyModuleApi();
            var moduleId = moduleId_example;  // String |  (default to null)

            try {
                ModuleDescriptor result = apiInstance.getModule(moduleId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyModuleApi.getModule: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyModuleApi();
$moduleId = moduleId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyModuleApi->new();
my $moduleId = moduleId_example; # String | 

eval {
    my $result = $api_instance->getModule(moduleId => $moduleId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyModuleApi->getModule: $@\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.ProxyModuleApi()
moduleId = moduleId_example # String |  (default to null)

try:
    api_response = api_instance.get_module(moduleId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyModuleApi->getModule: %s\n" % e)

extern crate ProxyModuleApi;

pub fn main() {
    let moduleId = moduleId_example; // String

    let mut context = ProxyModuleApi::Context::default();
    let result = client.getModule(moduleId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
module_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

ProxyTenant

createTenant

Create a new tenant

/_/proxy/tenants

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/proxy/tenants" \
 -d '{
  "name" : "name",
  "description" : "description",
  "id" : "id"
}'

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

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

public class ProxyTenantApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantApi apiInstance = new ProxyTenantApi();
        TenantDescriptor tenantDescriptor = ; // TenantDescriptor | 

        try {
            TenantDescriptor result = apiInstance.createTenant(tenantDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantApi#createTenant");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final TenantDescriptor tenantDescriptor = new TenantDescriptor(); // TenantDescriptor | 

try {
    final result = await api_instance.createTenant(tenantDescriptor);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createTenant: $e\n');
}

import org.openapitools.client.api.ProxyTenantApi;

public class ProxyTenantApiExample {
    public static void main(String[] args) {
        ProxyTenantApi apiInstance = new ProxyTenantApi();
        TenantDescriptor tenantDescriptor = ; // TenantDescriptor | 

        try {
            TenantDescriptor result = apiInstance.createTenant(tenantDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantApi#createTenant");
            e.printStackTrace();
        }
    }
}



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

[apiInstance createTenantWith:tenantDescriptor
              completionHandler: ^(TenantDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantApi()
var tenantDescriptor = ; // {TenantDescriptor} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantApi();
            var tenantDescriptor = new TenantDescriptor(); // TenantDescriptor | 

            try {
                TenantDescriptor result = apiInstance.createTenant(tenantDescriptor);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantApi.createTenant: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantApi();
$tenantDescriptor = ; // TenantDescriptor | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantApi->new();
my $tenantDescriptor = WWW::OPenAPIClient::Object::TenantDescriptor->new(); # TenantDescriptor | 

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

try:
    api_response = api_instance.create_tenant(tenantDescriptor)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantApi->createTenant: %s\n" % e)

extern crate ProxyTenantApi;

pub fn main() {
    let tenantDescriptor = ; // TenantDescriptor

    let mut context = ProxyTenantApi::Context::default();
    let result = client.createTenant(tenantDescriptor, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
tenantDescriptor *

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String
Location	String		URI to the environment entry instance

deleteTenant

Remove a tenant

/_/proxy/tenants/{tenant_id}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}"

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

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

public class ProxyTenantApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantApi apiInstance = new ProxyTenantApi();
        String tenantId = tenantId_example; // String | 

        try {
            apiInstance.deleteTenant(tenantId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantApi#deleteTenant");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 

try {
    final result = await api_instance.deleteTenant(tenantId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteTenant: $e\n');
}

import org.openapitools.client.api.ProxyTenantApi;

public class ProxyTenantApiExample {
    public static void main(String[] args) {
        ProxyTenantApi apiInstance = new ProxyTenantApi();
        String tenantId = tenantId_example; // String | 

        try {
            apiInstance.deleteTenant(tenantId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantApi#deleteTenant");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantApi *apiInstance = [[ProxyTenantApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantApi()
var tenantId = tenantId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantApi();
            var tenantId = tenantId_example;  // String |  (default to null)

            try {
                apiInstance.deleteTenant(tenantId);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantApi.deleteTenant: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantApi();
$tenantId = tenantId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantApi->new();
my $tenantId = tenantId_example; # String | 

eval {
    $api_instance->deleteTenant(tenantId => $tenantId);
};
if ($@) {
    warn "Exception when calling ProxyTenantApi->deleteTenant: $@\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.ProxyTenantApi()
tenantId = tenantId_example # String |  (default to null)

try:
    api_instance.delete_tenant(tenantId)
except ApiException as e:
    print("Exception when calling ProxyTenantApi->deleteTenant: %s\n" % e)

extern crate ProxyTenantApi;

pub fn main() {
    let tenantId = tenantId_example; // String

    let mut context = ProxyTenantApi::Context::default();
    let result = client.deleteTenant(tenantId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getAllTenants

List all tenants

/_/proxy/tenants

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/tenants"

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

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

public class ProxyTenantApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantApi apiInstance = new ProxyTenantApi();

        try {
            array[TenantDescriptor] result = apiInstance.getAllTenants();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantApi#getAllTenants");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getAllTenants();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllTenants: $e\n');
}

import org.openapitools.client.api.ProxyTenantApi;

public class ProxyTenantApiExample {
    public static void main(String[] args) {
        ProxyTenantApi apiInstance = new ProxyTenantApi();

        try {
            array[TenantDescriptor] result = apiInstance.getAllTenants();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantApi#getAllTenants");
            e.printStackTrace();
        }
    }
}



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

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantApi();

            try {
                array[TenantDescriptor] result = apiInstance.getAllTenants();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantApi.getAllTenants: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate ProxyTenantApi;

pub fn main() {

    let mut context = ProxyTenantApi::Context::default();
    let result = client.getAllTenants(&context).wait();

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

Scopes

Parameters

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getTenant

Retrieve a tenant

/_/proxy/tenants/{tenant_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}"

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

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

public class ProxyTenantApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantApi apiInstance = new ProxyTenantApi();
        String tenantId = tenantId_example; // String | 

        try {
            TenantDescriptor result = apiInstance.getTenant(tenantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantApi#getTenant");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 

try {
    final result = await api_instance.getTenant(tenantId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getTenant: $e\n');
}

import org.openapitools.client.api.ProxyTenantApi;

public class ProxyTenantApiExample {
    public static void main(String[] args) {
        ProxyTenantApi apiInstance = new ProxyTenantApi();
        String tenantId = tenantId_example; // String | 

        try {
            TenantDescriptor result = apiInstance.getTenant(tenantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantApi#getTenant");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantApi *apiInstance = [[ProxyTenantApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)

[apiInstance getTenantWith:tenantId
              completionHandler: ^(TenantDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantApi()
var tenantId = tenantId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantApi();
            var tenantId = tenantId_example;  // String |  (default to null)

            try {
                TenantDescriptor result = apiInstance.getTenant(tenantId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantApi.getTenant: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantApi();
$tenantId = tenantId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantApi->new();
my $tenantId = tenantId_example; # String | 

eval {
    my $result = $api_instance->getTenant(tenantId => $tenantId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantApi->getTenant: $@\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.ProxyTenantApi()
tenantId = tenantId_example # String |  (default to null)

try:
    api_response = api_instance.get_tenant(tenantId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantApi->getTenant: %s\n" % e)

extern crate ProxyTenantApi;

pub fn main() {
    let tenantId = tenantId_example; // String

    let mut context = ProxyTenantApi::Context::default();
    let result = client.getTenant(tenantId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

updateTenant

Update a tenant

/_/proxy/tenants/{tenant_id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}" \
 -d '{
  "name" : "name",
  "description" : "description",
  "id" : "id"
}'

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

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

public class ProxyTenantApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantApi apiInstance = new ProxyTenantApi();
        String tenantId = tenantId_example; // String | 
        TenantDescriptor tenantDescriptor = ; // TenantDescriptor | 

        try {
            TenantDescriptor result = apiInstance.updateTenant(tenantId, tenantDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantApi#updateTenant");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 
final TenantDescriptor tenantDescriptor = new TenantDescriptor(); // TenantDescriptor | 

try {
    final result = await api_instance.updateTenant(tenantId, tenantDescriptor);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateTenant: $e\n');
}

import org.openapitools.client.api.ProxyTenantApi;

public class ProxyTenantApiExample {
    public static void main(String[] args) {
        ProxyTenantApi apiInstance = new ProxyTenantApi();
        String tenantId = tenantId_example; // String | 
        TenantDescriptor tenantDescriptor = ; // TenantDescriptor | 

        try {
            TenantDescriptor result = apiInstance.updateTenant(tenantId, tenantDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantApi#updateTenant");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantApi *apiInstance = [[ProxyTenantApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)
TenantDescriptor *tenantDescriptor = ; // 

[apiInstance updateTenantWith:tenantId
    tenantDescriptor:tenantDescriptor
              completionHandler: ^(TenantDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantApi()
var tenantId = tenantId_example; // {String} 
var tenantDescriptor = ; // {TenantDescriptor} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantApi();
            var tenantId = tenantId_example;  // String |  (default to null)
            var tenantDescriptor = new TenantDescriptor(); // TenantDescriptor | 

            try {
                TenantDescriptor result = apiInstance.updateTenant(tenantId, tenantDescriptor);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantApi.updateTenant: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantApi();
$tenantId = tenantId_example; // String | 
$tenantDescriptor = ; // TenantDescriptor | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantApi->new();
my $tenantId = tenantId_example; # String | 
my $tenantDescriptor = WWW::OPenAPIClient::Object::TenantDescriptor->new(); # TenantDescriptor | 

eval {
    my $result = $api_instance->updateTenant(tenantId => $tenantId, tenantDescriptor => $tenantDescriptor);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantApi->updateTenant: $@\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.ProxyTenantApi()
tenantId = tenantId_example # String |  (default to null)
tenantDescriptor =  # TenantDescriptor | 

try:
    api_response = api_instance.update_tenant(tenantId, tenantDescriptor)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantApi->updateTenant: %s\n" % e)

extern crate ProxyTenantApi;

pub fn main() {
    let tenantId = tenantId_example; // String
    let tenantDescriptor = ; // TenantDescriptor

    let mut context = ProxyTenantApi::Context::default();
    let result = client.updateTenant(tenantId, tenantDescriptor, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Body parameters

Name	Description
tenantDescriptor *

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

ProxyTenantInstallation

createInstallJob

Enable, disable or upgrade one or more modules for tenant. The request body and response body is of the same type TenantModuleDescriptorList. This list includes one or more modules to be enabled, disabled or upgraded. The request is the initial desired changes and the response is the list of changes that must be fulfilled to satisfy dependencies. This service will eventually partially replace /_/proxy/tenants/{tenant}/modules . It also allows enabling multiple modules in one transaction. For simulate=true, the response, can be viewed as a recipe for what must be deployed (optionally) and enabled/disabled by the existing tenants-modules CRUD service.

/_/proxy/tenants/{tenant_id}/install

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/install?preRelease=preRelease_example&npmSnapshot=npmSnapshot_example&async=true&deploy=true&ignoreErrors=true&invoke=invoke_example¶llel=56&purge=true&reinstall=true&simulate=true&tenantParameters=tenantParameters_example&depCheck=true" \
 -d '{
  "stage" : "pending",
  "action" : "enable",
  "from" : "from",
  "id" : "id",
  "message" : "message"
}'

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

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

public class ProxyTenantInstallationApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantInstallationApi apiInstance = new ProxyTenantInstallationApi();
        String tenantId = tenantId_example; // String | 
        array[TenantModuleDescriptor] tenantModuleDescriptor = ; // array[TenantModuleDescriptor] | 
        String preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
        String npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
        Boolean async = true; // Boolean | Whether to install in the background.
        Boolean deploy = true; // Boolean | Whether to deploy (or undeploy if disabling).
        Boolean ignoreErrors = true; // Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).

        String invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").

        Integer parallel = 56; // Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.

        Boolean purge = true; // Boolean | Disabled modules will also be purged.
        Boolean reinstall = true; // Boolean | Whether to install modules even if up-to-update.
        Boolean simulate = true; // Boolean | Whether the installation is simulated
        String tenantParameters = tenantParameters_example; // String | Parameters for tenant init
        Boolean depCheck = true; // Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.


        try {
            array[TenantModuleDescriptor] result = apiInstance.createInstallJob(tenantId, tenantModuleDescriptor, preRelease, npmSnapshot, async, deploy, ignoreErrors, invoke, parallel, purge, reinstall, simulate, tenantParameters, depCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInstallationApi#createInstallJob");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 
final array[TenantModuleDescriptor] tenantModuleDescriptor = new array[TenantModuleDescriptor](); // array[TenantModuleDescriptor] | 
final String preRelease = new String(); // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
final String npmSnapshot = new String(); // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
final Boolean async = new Boolean(); // Boolean | Whether to install in the background.
final Boolean deploy = new Boolean(); // Boolean | Whether to deploy (or undeploy if disabling).
final Boolean ignoreErrors = new Boolean(); // Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).

final String invoke = new String(); // String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").

final Integer parallel = new Integer(); // Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.

final Boolean purge = new Boolean(); // Boolean | Disabled modules will also be purged.
final Boolean reinstall = new Boolean(); // Boolean | Whether to install modules even if up-to-update.
final Boolean simulate = new Boolean(); // Boolean | Whether the installation is simulated
final String tenantParameters = new String(); // String | Parameters for tenant init
final Boolean depCheck = new Boolean(); // Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.


try {
    final result = await api_instance.createInstallJob(tenantId, tenantModuleDescriptor, preRelease, npmSnapshot, async, deploy, ignoreErrors, invoke, parallel, purge, reinstall, simulate, tenantParameters, depCheck);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createInstallJob: $e\n');
}

import org.openapitools.client.api.ProxyTenantInstallationApi;

public class ProxyTenantInstallationApiExample {
    public static void main(String[] args) {
        ProxyTenantInstallationApi apiInstance = new ProxyTenantInstallationApi();
        String tenantId = tenantId_example; // String | 
        array[TenantModuleDescriptor] tenantModuleDescriptor = ; // array[TenantModuleDescriptor] | 
        String preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
        String npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
        Boolean async = true; // Boolean | Whether to install in the background.
        Boolean deploy = true; // Boolean | Whether to deploy (or undeploy if disabling).
        Boolean ignoreErrors = true; // Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).

        String invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").

        Integer parallel = 56; // Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.

        Boolean purge = true; // Boolean | Disabled modules will also be purged.
        Boolean reinstall = true; // Boolean | Whether to install modules even if up-to-update.
        Boolean simulate = true; // Boolean | Whether the installation is simulated
        String tenantParameters = tenantParameters_example; // String | Parameters for tenant init
        Boolean depCheck = true; // Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.


        try {
            array[TenantModuleDescriptor] result = apiInstance.createInstallJob(tenantId, tenantModuleDescriptor, preRelease, npmSnapshot, async, deploy, ignoreErrors, invoke, parallel, purge, reinstall, simulate, tenantParameters, depCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInstallationApi#createInstallJob");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantInstallationApi *apiInstance = [[ProxyTenantInstallationApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)
array[TenantModuleDescriptor] *tenantModuleDescriptor = ; // 
String *preRelease = preRelease_example; // Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional) (default to true)
String *npmSnapshot = npmSnapshot_example; // Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional) (default to true)
Boolean *async = true; // Whether to install in the background. (optional) (default to false)
Boolean *deploy = true; // Whether to deploy (or undeploy if disabling). (optional) (default to false)
Boolean *ignoreErrors = true; // Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).
 (optional) (default to false)
String *invoke = invoke_example; // Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").
 (optional) (default to true)
Integer *parallel = 56; // Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.
 (optional) (default to 1)
Boolean *purge = true; // Disabled modules will also be purged. (optional) (default to false)
Boolean *reinstall = true; // Whether to install modules even if up-to-update. (optional) (default to false)
Boolean *simulate = true; // Whether the installation is simulated (optional) (default to false)
String *tenantParameters = tenantParameters_example; // Parameters for tenant init (optional) (default to null)
Boolean *depCheck = true; // Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.
 (optional) (default to true)

[apiInstance createInstallJobWith:tenantId
    tenantModuleDescriptor:tenantModuleDescriptor
    preRelease:preRelease
    npmSnapshot:npmSnapshot
    async:async
    deploy:deploy
    ignoreErrors:ignoreErrors
    invoke:invoke
    parallel:parallel
    purge:purge
    reinstall:reinstall
    simulate:simulate
    tenantParameters:tenantParameters
    depCheck:depCheck
              completionHandler: ^(array[TenantModuleDescriptor] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantInstallationApi()
var tenantId = tenantId_example; // {String} 
var tenantModuleDescriptor = ; // {array[TenantModuleDescriptor]} 
var opts = {
  'preRelease': preRelease_example, // {String} Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
  'npmSnapshot': npmSnapshot_example, // {String} Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
  'async': true, // {Boolean} Whether to install in the background.
  'deploy': true, // {Boolean} Whether to deploy (or undeploy if disabling).
  'ignoreErrors': true, // {Boolean} Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).

  'invoke': invoke_example, // {String} Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").

  'parallel': 56, // {Integer} Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.

  'purge': true, // {Boolean} Disabled modules will also be purged.
  'reinstall': true, // {Boolean} Whether to install modules even if up-to-update.
  'simulate': true, // {Boolean} Whether the installation is simulated
  'tenantParameters': tenantParameters_example, // {String} Parameters for tenant init
  'depCheck': true // {Boolean} Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.

};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantInstallationApi();
            var tenantId = tenantId_example;  // String |  (default to null)
            var tenantModuleDescriptor = new array[TenantModuleDescriptor](); // array[TenantModuleDescriptor] | 
            var preRelease = preRelease_example;  // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional)  (default to true)
            var npmSnapshot = npmSnapshot_example;  // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional)  (default to true)
            var async = true;  // Boolean | Whether to install in the background. (optional)  (default to false)
            var deploy = true;  // Boolean | Whether to deploy (or undeploy if disabling). (optional)  (default to false)
            var ignoreErrors = true;  // Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).
 (optional)  (default to false)
            var invoke = invoke_example;  // String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").
 (optional)  (default to true)
            var parallel = 56;  // Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.
 (optional)  (default to 1)
            var purge = true;  // Boolean | Disabled modules will also be purged. (optional)  (default to false)
            var reinstall = true;  // Boolean | Whether to install modules even if up-to-update. (optional)  (default to false)
            var simulate = true;  // Boolean | Whether the installation is simulated (optional)  (default to false)
            var tenantParameters = tenantParameters_example;  // String | Parameters for tenant init (optional)  (default to null)
            var depCheck = true;  // Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.
 (optional)  (default to true)

            try {
                array[TenantModuleDescriptor] result = apiInstance.createInstallJob(tenantId, tenantModuleDescriptor, preRelease, npmSnapshot, async, deploy, ignoreErrors, invoke, parallel, purge, reinstall, simulate, tenantParameters, depCheck);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantInstallationApi.createInstallJob: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantInstallationApi();
$tenantId = tenantId_example; // String | 
$tenantModuleDescriptor = ; // array[TenantModuleDescriptor] | 
$preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
$npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
$async = true; // Boolean | Whether to install in the background.
$deploy = true; // Boolean | Whether to deploy (or undeploy if disabling).
$ignoreErrors = true; // Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).

$invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").

$parallel = 56; // Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.

$purge = true; // Boolean | Disabled modules will also be purged.
$reinstall = true; // Boolean | Whether to install modules even if up-to-update.
$simulate = true; // Boolean | Whether the installation is simulated
$tenantParameters = tenantParameters_example; // String | Parameters for tenant init
$depCheck = true; // Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.


try {
    $result = $api_instance->createInstallJob($tenantId, $tenantModuleDescriptor, $preRelease, $npmSnapshot, $async, $deploy, $ignoreErrors, $invoke, $parallel, $purge, $reinstall, $simulate, $tenantParameters, $depCheck);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyTenantInstallationApi->createInstallJob: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantInstallationApi->new();
my $tenantId = tenantId_example; # String | 
my $tenantModuleDescriptor = [WWW::OPenAPIClient::Object::array[TenantModuleDescriptor]->new()]; # array[TenantModuleDescriptor] | 
my $preRelease = preRelease_example; # String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
my $npmSnapshot = npmSnapshot_example; # String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
my $async = true; # Boolean | Whether to install in the background.
my $deploy = true; # Boolean | Whether to deploy (or undeploy if disabling).
my $ignoreErrors = true; # Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).

my $invoke = invoke_example; # String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").

my $parallel = 56; # Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.

my $purge = true; # Boolean | Disabled modules will also be purged.
my $reinstall = true; # Boolean | Whether to install modules even if up-to-update.
my $simulate = true; # Boolean | Whether the installation is simulated
my $tenantParameters = tenantParameters_example; # String | Parameters for tenant init
my $depCheck = true; # Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.


eval {
    my $result = $api_instance->createInstallJob(tenantId => $tenantId, tenantModuleDescriptor => $tenantModuleDescriptor, preRelease => $preRelease, npmSnapshot => $npmSnapshot, async => $async, deploy => $deploy, ignoreErrors => $ignoreErrors, invoke => $invoke, parallel => $parallel, purge => $purge, reinstall => $reinstall, simulate => $simulate, tenantParameters => $tenantParameters, depCheck => $depCheck);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantInstallationApi->createInstallJob: $@\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.ProxyTenantInstallationApi()
tenantId = tenantId_example # String |  (default to null)
tenantModuleDescriptor =  # array[TenantModuleDescriptor] | 
preRelease = preRelease_example # String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional) (default to true)
npmSnapshot = npmSnapshot_example # String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional) (default to true)
async = true # Boolean | Whether to install in the background. (optional) (default to false)
deploy = true # Boolean | Whether to deploy (or undeploy if disabling). (optional) (default to false)
ignoreErrors = true # Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).
 (optional) (default to false)
invoke = invoke_example # String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").
 (optional) (default to true)
parallel = 56 # Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.
 (optional) (default to 1)
purge = true # Boolean | Disabled modules will also be purged. (optional) (default to false)
reinstall = true # Boolean | Whether to install modules even if up-to-update. (optional) (default to false)
simulate = true # Boolean | Whether the installation is simulated (optional) (default to false)
tenantParameters = tenantParameters_example # String | Parameters for tenant init (optional) (default to null)
depCheck = true # Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.
 (optional) (default to true)

try:
    api_response = api_instance.create_install_job(tenantId, tenantModuleDescriptor, preRelease=preRelease, npmSnapshot=npmSnapshot, async=async, deploy=deploy, ignoreErrors=ignoreErrors, invoke=invoke, parallel=parallel, purge=purge, reinstall=reinstall, simulate=simulate, tenantParameters=tenantParameters, depCheck=depCheck)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantInstallationApi->createInstallJob: %s\n" % e)

extern crate ProxyTenantInstallationApi;

pub fn main() {
    let tenantId = tenantId_example; // String
    let tenantModuleDescriptor = ; // array[TenantModuleDescriptor]
    let preRelease = preRelease_example; // String
    let npmSnapshot = npmSnapshot_example; // String
    let async = true; // Boolean
    let deploy = true; // Boolean
    let ignoreErrors = true; // Boolean
    let invoke = invoke_example; // String
    let parallel = 56; // Integer
    let purge = true; // Boolean
    let reinstall = true; // Boolean
    let simulate = true; // Boolean
    let tenantParameters = tenantParameters_example; // String
    let depCheck = true; // Boolean

    let mut context = ProxyTenantInstallationApi::Context::default();
    let result = client.createInstallJob(tenantId, tenantModuleDescriptor, preRelease, npmSnapshot, async, deploy, ignoreErrors, invoke, parallel, purge, reinstall, simulate, tenantParameters, depCheck, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Body parameters

Name	Description
tenantModuleDescriptor *

Query parameters

Name	Description
preRelease	String Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
npmSnapshot	String Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
async	Boolean Whether to install in the background.
deploy	Boolean Whether to deploy (or undeploy if disabling).
ignoreErrors	Boolean Okapi 4.2.0 and later, it is possible to ignore errors during the install operation. This is done by supplying parameter `ignoreErrors=true`. In this case, Okapi will try to upgrade all modules in the modules list, regardless if one of them fails. However, for individual modules, if they fail, their upgrade will not be committed. This is an experimental parameter which was added to be able to inspect all problem(s) with module upgrade(s).
invoke	String Whether to invoke for tenant init/permissions/purge. Use "true" to invoke, "false" to not invoke. Any other value is a regular expression that is matched against the module ID. If that pattern matches, invoke is performed (same as "true").
parallel	Integer Number of parallel calls to tenant interfaces of modules. A value of 1 means calls are happening in sequence. If depCheck=false and parallel>1, the invocation will be rejected.
purge	Boolean Disabled modules will also be purged.
reinstall	Boolean Whether to install modules even if up-to-update.
simulate	Boolean Whether the installation is simulated
tenantParameters	String Parameters for tenant init
depCheck	Boolean Whether to check dependencies of modules before being installed. Modules are installed exactly in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be rejected.

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

Schema
Headers

Name	Type	Format	Description
Location	String		URI to the environment entry instance
X-Okapi-Trace	String

createUpgradeJob

Upgrade each module to the latest version. The upgrade is rejected if it would violate the interface dependencies of the modules. The response is a list of modules that have been enabled, disabled or upgraded to perform the upgrade.

/_/proxy/tenants/{tenant_id}/upgrade

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/upgrade?preRelease=preRelease_example&npmSnapshot=npmSnapshot_example&async=true&deploy=true&ignoreErrors=true&invoke=invoke_example¶llel=56&purge=true&reinstall=true&simulate=true&tenantParameters=tenantParameters_example&depCheck=true"

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

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

public class ProxyTenantInstallationApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantInstallationApi apiInstance = new ProxyTenantInstallationApi();
        String tenantId = tenantId_example; // String | 
        String preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
        String npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
        Boolean async = true; // Boolean | Whether to install in the background.
        Boolean deploy = true; // Boolean | Whether to deploy (or undeploy if disabling).
        Boolean ignoreErrors = true; // Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).

        String invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").

        Integer parallel = 56; // Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.

        Boolean purge = true; // Boolean | Disabled modules will also be purged.
        Boolean reinstall = true; // Boolean | Whether to install modules even if up-to-update.
        Boolean simulate = true; // Boolean | Whether the installation is simulated
        String tenantParameters = tenantParameters_example; // String | Parameters for tenant init
        Boolean depCheck = true; // Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.


        try {
            array[TenantModuleDescriptor] result = apiInstance.createUpgradeJob(tenantId, preRelease, npmSnapshot, async, deploy, ignoreErrors, invoke, parallel, purge, reinstall, simulate, tenantParameters, depCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInstallationApi#createUpgradeJob");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 
final String preRelease = new String(); // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
final String npmSnapshot = new String(); // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
final Boolean async = new Boolean(); // Boolean | Whether to install in the background.
final Boolean deploy = new Boolean(); // Boolean | Whether to deploy (or undeploy if disabling).
final Boolean ignoreErrors = new Boolean(); // Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).

final String invoke = new String(); // String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").

final Integer parallel = new Integer(); // Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.

final Boolean purge = new Boolean(); // Boolean | Disabled modules will also be purged.
final Boolean reinstall = new Boolean(); // Boolean | Whether to install modules even if up-to-update.
final Boolean simulate = new Boolean(); // Boolean | Whether the installation is simulated
final String tenantParameters = new String(); // String | Parameters for tenant init
final Boolean depCheck = new Boolean(); // Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.


try {
    final result = await api_instance.createUpgradeJob(tenantId, preRelease, npmSnapshot, async, deploy, ignoreErrors, invoke, parallel, purge, reinstall, simulate, tenantParameters, depCheck);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createUpgradeJob: $e\n');
}

import org.openapitools.client.api.ProxyTenantInstallationApi;

public class ProxyTenantInstallationApiExample {
    public static void main(String[] args) {
        ProxyTenantInstallationApi apiInstance = new ProxyTenantInstallationApi();
        String tenantId = tenantId_example; // String | 
        String preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
        String npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
        Boolean async = true; // Boolean | Whether to install in the background.
        Boolean deploy = true; // Boolean | Whether to deploy (or undeploy if disabling).
        Boolean ignoreErrors = true; // Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).

        String invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").

        Integer parallel = 56; // Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.

        Boolean purge = true; // Boolean | Disabled modules will also be purged.
        Boolean reinstall = true; // Boolean | Whether to install modules even if up-to-update.
        Boolean simulate = true; // Boolean | Whether the installation is simulated
        String tenantParameters = tenantParameters_example; // String | Parameters for tenant init
        Boolean depCheck = true; // Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.


        try {
            array[TenantModuleDescriptor] result = apiInstance.createUpgradeJob(tenantId, preRelease, npmSnapshot, async, deploy, ignoreErrors, invoke, parallel, purge, reinstall, simulate, tenantParameters, depCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInstallationApi#createUpgradeJob");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantInstallationApi *apiInstance = [[ProxyTenantInstallationApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)
String *preRelease = preRelease_example; // Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional) (default to true)
String *npmSnapshot = npmSnapshot_example; // Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional) (default to true)
Boolean *async = true; // Whether to install in the background. (optional) (default to false)
Boolean *deploy = true; // Whether to deploy (or undeploy if disabling). (optional) (default to false)
Boolean *ignoreErrors = true; // Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).
 (optional) (default to false)
String *invoke = invoke_example; // Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").
 (optional) (default to true)
Integer *parallel = 56; // Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.
 (optional) (default to 1)
Boolean *purge = true; // Disabled modules will also be purged. (optional) (default to false)
Boolean *reinstall = true; // Whether to install modules even if up-to-update. (optional) (default to false)
Boolean *simulate = true; // Whether the installation is simulated (optional) (default to false)
String *tenantParameters = tenantParameters_example; // Parameters for tenant init (optional) (default to null)
Boolean *depCheck = true; // Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.
 (optional) (default to true)

[apiInstance createUpgradeJobWith:tenantId
    preRelease:preRelease
    npmSnapshot:npmSnapshot
    async:async
    deploy:deploy
    ignoreErrors:ignoreErrors
    invoke:invoke
    parallel:parallel
    purge:purge
    reinstall:reinstall
    simulate:simulate
    tenantParameters:tenantParameters
    depCheck:depCheck
              completionHandler: ^(array[TenantModuleDescriptor] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantInstallationApi()
var tenantId = tenantId_example; // {String} 
var opts = {
  'preRelease': preRelease_example, // {String} Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
  'npmSnapshot': npmSnapshot_example, // {String} Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
  'async': true, // {Boolean} Whether to install in the background.
  'deploy': true, // {Boolean} Whether to deploy (or undeploy if disabling).
  'ignoreErrors': true, // {Boolean} Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).

  'invoke': invoke_example, // {String} Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").

  'parallel': 56, // {Integer} Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.

  'purge': true, // {Boolean} Disabled modules will also be purged.
  'reinstall': true, // {Boolean} Whether to install modules even if up-to-update.
  'simulate': true, // {Boolean} Whether the installation is simulated
  'tenantParameters': tenantParameters_example, // {String} Parameters for tenant init
  'depCheck': true // {Boolean} Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.

};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantInstallationApi();
            var tenantId = tenantId_example;  // String |  (default to null)
            var preRelease = preRelease_example;  // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional)  (default to true)
            var npmSnapshot = npmSnapshot_example;  // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional)  (default to true)
            var async = true;  // Boolean | Whether to install in the background. (optional)  (default to false)
            var deploy = true;  // Boolean | Whether to deploy (or undeploy if disabling). (optional)  (default to false)
            var ignoreErrors = true;  // Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).
 (optional)  (default to false)
            var invoke = invoke_example;  // String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").
 (optional)  (default to true)
            var parallel = 56;  // Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.
 (optional)  (default to 1)
            var purge = true;  // Boolean | Disabled modules will also be purged. (optional)  (default to false)
            var reinstall = true;  // Boolean | Whether to install modules even if up-to-update. (optional)  (default to false)
            var simulate = true;  // Boolean | Whether the installation is simulated (optional)  (default to false)
            var tenantParameters = tenantParameters_example;  // String | Parameters for tenant init (optional)  (default to null)
            var depCheck = true;  // Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.
 (optional)  (default to true)

            try {
                array[TenantModuleDescriptor] result = apiInstance.createUpgradeJob(tenantId, preRelease, npmSnapshot, async, deploy, ignoreErrors, invoke, parallel, purge, reinstall, simulate, tenantParameters, depCheck);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantInstallationApi.createUpgradeJob: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantInstallationApi();
$tenantId = tenantId_example; // String | 
$preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
$npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
$async = true; // Boolean | Whether to install in the background.
$deploy = true; // Boolean | Whether to deploy (or undeploy if disabling).
$ignoreErrors = true; // Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).

$invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").

$parallel = 56; // Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.

$purge = true; // Boolean | Disabled modules will also be purged.
$reinstall = true; // Boolean | Whether to install modules even if up-to-update.
$simulate = true; // Boolean | Whether the installation is simulated
$tenantParameters = tenantParameters_example; // String | Parameters for tenant init
$depCheck = true; // Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.


try {
    $result = $api_instance->createUpgradeJob($tenantId, $preRelease, $npmSnapshot, $async, $deploy, $ignoreErrors, $invoke, $parallel, $purge, $reinstall, $simulate, $tenantParameters, $depCheck);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyTenantInstallationApi->createUpgradeJob: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantInstallationApi->new();
my $tenantId = tenantId_example; # String | 
my $preRelease = preRelease_example; # String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
my $npmSnapshot = npmSnapshot_example; # String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
my $async = true; # Boolean | Whether to install in the background.
my $deploy = true; # Boolean | Whether to deploy (or undeploy if disabling).
my $ignoreErrors = true; # Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).

my $invoke = invoke_example; # String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").

my $parallel = 56; # Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.

my $purge = true; # Boolean | Disabled modules will also be purged.
my $reinstall = true; # Boolean | Whether to install modules even if up-to-update.
my $simulate = true; # Boolean | Whether the installation is simulated
my $tenantParameters = tenantParameters_example; # String | Parameters for tenant init
my $depCheck = true; # Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.


eval {
    my $result = $api_instance->createUpgradeJob(tenantId => $tenantId, preRelease => $preRelease, npmSnapshot => $npmSnapshot, async => $async, deploy => $deploy, ignoreErrors => $ignoreErrors, invoke => $invoke, parallel => $parallel, purge => $purge, reinstall => $reinstall, simulate => $simulate, tenantParameters => $tenantParameters, depCheck => $depCheck);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantInstallationApi->createUpgradeJob: $@\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.ProxyTenantInstallationApi()
tenantId = tenantId_example # String |  (default to null)
preRelease = preRelease_example # String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional) (default to true)
npmSnapshot = npmSnapshot_example # String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional) (default to true)
async = true # Boolean | Whether to install in the background. (optional) (default to false)
deploy = true # Boolean | Whether to deploy (or undeploy if disabling). (optional) (default to false)
ignoreErrors = true # Boolean | Okapi 4.2.0 and later, it is possible to ignore errors during the
install operation. This is done by supplying parameter `ignoreErrors=true`.
In this case, Okapi will try to upgrade all modules in the modules list,
regardless if one of them fails. However, for individual modules, if they
fail, their upgrade will not be committed. This is an experimental parameter
which was added to be able to inspect all problem(s) with module upgrade(s).
 (optional) (default to false)
invoke = invoke_example # String | Whether to invoke for tenant init/permissions/purge. Use
 "true" to invoke, "false" to not invoke. Any other value
 is a regular expression that is matched against the module ID.
 If that pattern matches, invoke is performed (same as "true").
 (optional) (default to true)
parallel = 56 # Integer | Number of parallel calls to tenant interfaces of modules.
A value of 1 means calls are happening in sequence.
If depCheck=false and parallel>1, the invocation will be rejected.
 (optional) (default to 1)
purge = true # Boolean | Disabled modules will also be purged. (optional) (default to false)
reinstall = true # Boolean | Whether to install modules even if up-to-update. (optional) (default to false)
simulate = true # Boolean | Whether the installation is simulated (optional) (default to false)
tenantParameters = tenantParameters_example # String | Parameters for tenant init (optional) (default to null)
depCheck = true # Boolean | Whether to check dependencies of modules before being installed. Modules are installed exactly
  in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be
  rejected.
 (optional) (default to true)

try:
    api_response = api_instance.create_upgrade_job(tenantId, preRelease=preRelease, npmSnapshot=npmSnapshot, async=async, deploy=deploy, ignoreErrors=ignoreErrors, invoke=invoke, parallel=parallel, purge=purge, reinstall=reinstall, simulate=simulate, tenantParameters=tenantParameters, depCheck=depCheck)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantInstallationApi->createUpgradeJob: %s\n" % e)

extern crate ProxyTenantInstallationApi;

pub fn main() {
    let tenantId = tenantId_example; // String
    let preRelease = preRelease_example; // String
    let npmSnapshot = npmSnapshot_example; // String
    let async = true; // Boolean
    let deploy = true; // Boolean
    let ignoreErrors = true; // Boolean
    let invoke = invoke_example; // String
    let parallel = 56; // Integer
    let purge = true; // Boolean
    let reinstall = true; // Boolean
    let simulate = true; // Boolean
    let tenantParameters = tenantParameters_example; // String
    let depCheck = true; // Boolean

    let mut context = ProxyTenantInstallationApi::Context::default();
    let result = client.createUpgradeJob(tenantId, preRelease, npmSnapshot, async, deploy, ignoreErrors, invoke, parallel, purge, reinstall, simulate, tenantParameters, depCheck, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Query parameters

Name	Description
preRelease	String Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
npmSnapshot	String Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
async	Boolean Whether to install in the background.
deploy	Boolean Whether to deploy (or undeploy if disabling).
ignoreErrors	Boolean Okapi 4.2.0 and later, it is possible to ignore errors during the install operation. This is done by supplying parameter `ignoreErrors=true`. In this case, Okapi will try to upgrade all modules in the modules list, regardless if one of them fails. However, for individual modules, if they fail, their upgrade will not be committed. This is an experimental parameter which was added to be able to inspect all problem(s) with module upgrade(s).
invoke	String Whether to invoke for tenant init/permissions/purge. Use "true" to invoke, "false" to not invoke. Any other value is a regular expression that is matched against the module ID. If that pattern matches, invoke is performed (same as "true").
parallel	Integer Number of parallel calls to tenant interfaces of modules. A value of 1 means calls are happening in sequence. If depCheck=false and parallel>1, the invocation will be rejected.
purge	Boolean Disabled modules will also be purged.
reinstall	Boolean Whether to install modules even if up-to-update.
simulate	Boolean Whether the installation is simulated
tenantParameters	String Parameters for tenant init
depCheck	Boolean Whether to check dependencies of modules before being installed. Modules are installed exactly in the order supplied by the client. If depCheck=false and parallel>1, the invocation will be rejected.

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

Schema
Headers

Name	Type	Format	Description
Location	String		URI to the environment entry instance
X-Okapi-Trace	String

deleteInstallJob

Delete install job

/_/proxy/tenants/{tenant_id}/install/{install_id}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/install/{install_id}"

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

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

public class ProxyTenantInstallationApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantInstallationApi apiInstance = new ProxyTenantInstallationApi();
        String installId = installId_example; // String | 
        String tenantId = tenantId_example; // String | 

        try {
            apiInstance.deleteInstallJob(installId, tenantId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInstallationApi#deleteInstallJob");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String installId = new String(); // String | 
final String tenantId = new String(); // String | 

try {
    final result = await api_instance.deleteInstallJob(installId, tenantId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteInstallJob: $e\n');
}

import org.openapitools.client.api.ProxyTenantInstallationApi;

public class ProxyTenantInstallationApiExample {
    public static void main(String[] args) {
        ProxyTenantInstallationApi apiInstance = new ProxyTenantInstallationApi();
        String installId = installId_example; // String | 
        String tenantId = tenantId_example; // String | 

        try {
            apiInstance.deleteInstallJob(installId, tenantId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInstallationApi#deleteInstallJob");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantInstallationApi *apiInstance = [[ProxyTenantInstallationApi alloc] init];
String *installId = installId_example; //  (default to null)
String *tenantId = tenantId_example; //  (default to null)

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantInstallationApi()
var installId = installId_example; // {String} 
var tenantId = tenantId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantInstallationApi();
            var installId = installId_example;  // String |  (default to null)
            var tenantId = tenantId_example;  // String |  (default to null)

            try {
                apiInstance.deleteInstallJob(installId, tenantId);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantInstallationApi.deleteInstallJob: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantInstallationApi();
$installId = installId_example; // String | 
$tenantId = tenantId_example; // String | 

try {
    $api_instance->deleteInstallJob($installId, $tenantId);
} catch (Exception $e) {
    echo 'Exception when calling ProxyTenantInstallationApi->deleteInstallJob: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantInstallationApi->new();
my $installId = installId_example; # String | 
my $tenantId = tenantId_example; # String | 

eval {
    $api_instance->deleteInstallJob(installId => $installId, tenantId => $tenantId);
};
if ($@) {
    warn "Exception when calling ProxyTenantInstallationApi->deleteInstallJob: $@\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.ProxyTenantInstallationApi()
installId = installId_example # String |  (default to null)
tenantId = tenantId_example # String |  (default to null)

try:
    api_instance.delete_install_job(installId, tenantId)
except ApiException as e:
    print("Exception when calling ProxyTenantInstallationApi->deleteInstallJob: %s\n" % e)

extern crate ProxyTenantInstallationApi;

pub fn main() {
    let installId = installId_example; // String
    let tenantId = tenantId_example; // String

    let mut context = ProxyTenantInstallationApi::Context::default();
    let result = client.deleteInstallJob(installId, tenantId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
install_id*	String Required
tenant_id*	String Required

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

deleteInstallJobs

Delete all completed install jobs

/_/proxy/tenants/{tenant_id}/install

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/install"

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

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

public class ProxyTenantInstallationApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantInstallationApi apiInstance = new ProxyTenantInstallationApi();
        String tenantId = tenantId_example; // String | 

        try {
            apiInstance.deleteInstallJobs(tenantId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInstallationApi#deleteInstallJobs");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 

try {
    final result = await api_instance.deleteInstallJobs(tenantId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteInstallJobs: $e\n');
}

import org.openapitools.client.api.ProxyTenantInstallationApi;

public class ProxyTenantInstallationApiExample {
    public static void main(String[] args) {
        ProxyTenantInstallationApi apiInstance = new ProxyTenantInstallationApi();
        String tenantId = tenantId_example; // String | 

        try {
            apiInstance.deleteInstallJobs(tenantId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInstallationApi#deleteInstallJobs");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantInstallationApi *apiInstance = [[ProxyTenantInstallationApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantInstallationApi()
var tenantId = tenantId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantInstallationApi();
            var tenantId = tenantId_example;  // String |  (default to null)

            try {
                apiInstance.deleteInstallJobs(tenantId);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantInstallationApi.deleteInstallJobs: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantInstallationApi();
$tenantId = tenantId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantInstallationApi->new();
my $tenantId = tenantId_example; # String | 

eval {
    $api_instance->deleteInstallJobs(tenantId => $tenantId);
};
if ($@) {
    warn "Exception when calling ProxyTenantInstallationApi->deleteInstallJobs: $@\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.ProxyTenantInstallationApi()
tenantId = tenantId_example # String |  (default to null)

try:
    api_instance.delete_install_jobs(tenantId)
except ApiException as e:
    print("Exception when calling ProxyTenantInstallationApi->deleteInstallJobs: %s\n" % e)

extern crate ProxyTenantInstallationApi;

pub fn main() {
    let tenantId = tenantId_example; // String

    let mut context = ProxyTenantInstallationApi::Context::default();
    let result = client.deleteInstallJobs(tenantId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getAllInstallJobs

Retrieve information about all install/upgrade jobs - including those that are ongoing.

/_/proxy/tenants/{tenant_id}/install

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/install"

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

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

public class ProxyTenantInstallationApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantInstallationApi apiInstance = new ProxyTenantInstallationApi();
        String tenantId = tenantId_example; // String | 

        try {
            array[InstallJob] result = apiInstance.getAllInstallJobs(tenantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInstallationApi#getAllInstallJobs");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 

try {
    final result = await api_instance.getAllInstallJobs(tenantId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllInstallJobs: $e\n');
}

import org.openapitools.client.api.ProxyTenantInstallationApi;

public class ProxyTenantInstallationApiExample {
    public static void main(String[] args) {
        ProxyTenantInstallationApi apiInstance = new ProxyTenantInstallationApi();
        String tenantId = tenantId_example; // String | 

        try {
            array[InstallJob] result = apiInstance.getAllInstallJobs(tenantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInstallationApi#getAllInstallJobs");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantInstallationApi *apiInstance = [[ProxyTenantInstallationApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)

[apiInstance getAllInstallJobsWith:tenantId
              completionHandler: ^(array[InstallJob] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantInstallationApi()
var tenantId = tenantId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantInstallationApi();
            var tenantId = tenantId_example;  // String |  (default to null)

            try {
                array[InstallJob] result = apiInstance.getAllInstallJobs(tenantId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantInstallationApi.getAllInstallJobs: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantInstallationApi();
$tenantId = tenantId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantInstallationApi->new();
my $tenantId = tenantId_example; # String | 

eval {
    my $result = $api_instance->getAllInstallJobs(tenantId => $tenantId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantInstallationApi->getAllInstallJobs: $@\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.ProxyTenantInstallationApi()
tenantId = tenantId_example # String |  (default to null)

try:
    api_response = api_instance.get_all_install_jobs(tenantId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantInstallationApi->getAllInstallJobs: %s\n" % e)

extern crate ProxyTenantInstallationApi;

pub fn main() {
    let tenantId = tenantId_example; // String

    let mut context = ProxyTenantInstallationApi::Context::default();
    let result = client.getAllInstallJobs(tenantId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getInstallJob

Get install job status

/_/proxy/tenants/{tenant_id}/install/{install_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/install/{install_id}"

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

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

public class ProxyTenantInstallationApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantInstallationApi apiInstance = new ProxyTenantInstallationApi();
        String installId = installId_example; // String | 
        String tenantId = tenantId_example; // String | 

        try {
            InstallJob result = apiInstance.getInstallJob(installId, tenantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInstallationApi#getInstallJob");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String installId = new String(); // String | 
final String tenantId = new String(); // String | 

try {
    final result = await api_instance.getInstallJob(installId, tenantId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getInstallJob: $e\n');
}

import org.openapitools.client.api.ProxyTenantInstallationApi;

public class ProxyTenantInstallationApiExample {
    public static void main(String[] args) {
        ProxyTenantInstallationApi apiInstance = new ProxyTenantInstallationApi();
        String installId = installId_example; // String | 
        String tenantId = tenantId_example; // String | 

        try {
            InstallJob result = apiInstance.getInstallJob(installId, tenantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInstallationApi#getInstallJob");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantInstallationApi *apiInstance = [[ProxyTenantInstallationApi alloc] init];
String *installId = installId_example; //  (default to null)
String *tenantId = tenantId_example; //  (default to null)

[apiInstance getInstallJobWith:installId
    tenantId:tenantId
              completionHandler: ^(InstallJob output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantInstallationApi()
var installId = installId_example; // {String} 
var tenantId = tenantId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantInstallationApi();
            var installId = installId_example;  // String |  (default to null)
            var tenantId = tenantId_example;  // String |  (default to null)

            try {
                InstallJob result = apiInstance.getInstallJob(installId, tenantId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantInstallationApi.getInstallJob: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantInstallationApi();
$installId = installId_example; // String | 
$tenantId = tenantId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantInstallationApi->new();
my $installId = installId_example; # String | 
my $tenantId = tenantId_example; # String | 

eval {
    my $result = $api_instance->getInstallJob(installId => $installId, tenantId => $tenantId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantInstallationApi->getInstallJob: $@\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.ProxyTenantInstallationApi()
installId = installId_example # String |  (default to null)
tenantId = tenantId_example # String |  (default to null)

try:
    api_response = api_instance.get_install_job(installId, tenantId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantInstallationApi->getInstallJob: %s\n" % e)

extern crate ProxyTenantInstallationApi;

pub fn main() {
    let installId = installId_example; // String
    let tenantId = tenantId_example; // String

    let mut context = ProxyTenantInstallationApi::Context::default();
    let result = client.getInstallJob(installId, tenantId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
install_id*	String Required
tenant_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

ProxyTenantInterface

getAllInterfaces

Get all interfaces for tenant

/_/proxy/tenants/{tenant_id}/interfaces

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/interfaces?full=true&type=type_example"

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

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

public class ProxyTenantInterfaceApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantInterfaceApi apiInstance = new ProxyTenantInterfaceApi();
        String tenantId = tenantId_example; // String | 
        Boolean full = true; // Boolean | Whether brief or full interface list
        String type = type_example; // String | Limit by interfaceType

        try {
            array[Object] result = apiInstance.getAllInterfaces(tenantId, full, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInterfaceApi#getAllInterfaces");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 
final Boolean full = new Boolean(); // Boolean | Whether brief or full interface list
final String type = new String(); // String | Limit by interfaceType

try {
    final result = await api_instance.getAllInterfaces(tenantId, full, type);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllInterfaces: $e\n');
}

import org.openapitools.client.api.ProxyTenantInterfaceApi;

public class ProxyTenantInterfaceApiExample {
    public static void main(String[] args) {
        ProxyTenantInterfaceApi apiInstance = new ProxyTenantInterfaceApi();
        String tenantId = tenantId_example; // String | 
        Boolean full = true; // Boolean | Whether brief or full interface list
        String type = type_example; // String | Limit by interfaceType

        try {
            array[Object] result = apiInstance.getAllInterfaces(tenantId, full, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInterfaceApi#getAllInterfaces");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantInterfaceApi *apiInstance = [[ProxyTenantInterfaceApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)
Boolean *full = true; // Whether brief or full interface list (optional) (default to false)
String *type = type_example; // Limit by interfaceType (optional) (default to null)

[apiInstance getAllInterfacesWith:tenantId
    full:full
    type:type
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantInterfaceApi()
var tenantId = tenantId_example; // {String} 
var opts = {
  'full': true, // {Boolean} Whether brief or full interface list
  'type': type_example // {String} Limit by interfaceType
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantInterfaceApi();
            var tenantId = tenantId_example;  // String |  (default to null)
            var full = true;  // Boolean | Whether brief or full interface list (optional)  (default to false)
            var type = type_example;  // String | Limit by interfaceType (optional)  (default to null)

            try {
                array[Object] result = apiInstance.getAllInterfaces(tenantId, full, type);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantInterfaceApi.getAllInterfaces: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantInterfaceApi();
$tenantId = tenantId_example; // String | 
$full = true; // Boolean | Whether brief or full interface list
$type = type_example; // String | Limit by interfaceType

try {
    $result = $api_instance->getAllInterfaces($tenantId, $full, $type);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyTenantInterfaceApi->getAllInterfaces: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantInterfaceApi->new();
my $tenantId = tenantId_example; # String | 
my $full = true; # Boolean | Whether brief or full interface list
my $type = type_example; # String | Limit by interfaceType

eval {
    my $result = $api_instance->getAllInterfaces(tenantId => $tenantId, full => $full, type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantInterfaceApi->getAllInterfaces: $@\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.ProxyTenantInterfaceApi()
tenantId = tenantId_example # String |  (default to null)
full = true # Boolean | Whether brief or full interface list (optional) (default to false)
type = type_example # String | Limit by interfaceType (optional) (default to null)

try:
    api_response = api_instance.get_all_interfaces(tenantId, full=full, type=type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantInterfaceApi->getAllInterfaces: %s\n" % e)

extern crate ProxyTenantInterfaceApi;

pub fn main() {
    let tenantId = tenantId_example; // String
    let full = true; // Boolean
    let type = type_example; // String

    let mut context = ProxyTenantInterfaceApi::Context::default();
    let result = client.getAllInterfaces(tenantId, full, type, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Query parameters

Name	Description
full	Boolean Whether brief or full interface list
type	String Limit by interfaceType

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getInterface

Get all modules that provide the specified interface ID. DEPRECATED Use /_/proxy/tenants/{tenant_id}/modules?provide={interface_id} instead.

/_/proxy/tenants/{tenant_id}/interfaces/{interface_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/interfaces/{interface_id}?type=type_example"

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

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

public class ProxyTenantInterfaceApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantInterfaceApi apiInstance = new ProxyTenantInterfaceApi();
        String interfaceId = interfaceId_example; // String | 
        String tenantId = tenantId_example; // String | 
        String type = type_example; // String | Limit by interfaceType

        try {
            array[TenantModuleDescriptor] result = apiInstance.getInterface(interfaceId, tenantId, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInterfaceApi#getInterface");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String interfaceId = new String(); // String | 
final String tenantId = new String(); // String | 
final String type = new String(); // String | Limit by interfaceType

try {
    final result = await api_instance.getInterface(interfaceId, tenantId, type);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getInterface: $e\n');
}

import org.openapitools.client.api.ProxyTenantInterfaceApi;

public class ProxyTenantInterfaceApiExample {
    public static void main(String[] args) {
        ProxyTenantInterfaceApi apiInstance = new ProxyTenantInterfaceApi();
        String interfaceId = interfaceId_example; // String | 
        String tenantId = tenantId_example; // String | 
        String type = type_example; // String | Limit by interfaceType

        try {
            array[TenantModuleDescriptor] result = apiInstance.getInterface(interfaceId, tenantId, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantInterfaceApi#getInterface");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantInterfaceApi *apiInstance = [[ProxyTenantInterfaceApi alloc] init];
String *interfaceId = interfaceId_example; //  (default to null)
String *tenantId = tenantId_example; //  (default to null)
String *type = type_example; // Limit by interfaceType (optional) (default to null)

[apiInstance getInterfaceWith:interfaceId
    tenantId:tenantId
    type:type
              completionHandler: ^(array[TenantModuleDescriptor] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantInterfaceApi()
var interfaceId = interfaceId_example; // {String} 
var tenantId = tenantId_example; // {String} 
var opts = {
  'type': type_example // {String} Limit by interfaceType
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantInterfaceApi();
            var interfaceId = interfaceId_example;  // String |  (default to null)
            var tenantId = tenantId_example;  // String |  (default to null)
            var type = type_example;  // String | Limit by interfaceType (optional)  (default to null)

            try {
                array[TenantModuleDescriptor] result = apiInstance.getInterface(interfaceId, tenantId, type);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantInterfaceApi.getInterface: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantInterfaceApi();
$interfaceId = interfaceId_example; // String | 
$tenantId = tenantId_example; // String | 
$type = type_example; // String | Limit by interfaceType

try {
    $result = $api_instance->getInterface($interfaceId, $tenantId, $type);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyTenantInterfaceApi->getInterface: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantInterfaceApi->new();
my $interfaceId = interfaceId_example; # String | 
my $tenantId = tenantId_example; # String | 
my $type = type_example; # String | Limit by interfaceType

eval {
    my $result = $api_instance->getInterface(interfaceId => $interfaceId, tenantId => $tenantId, type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantInterfaceApi->getInterface: $@\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.ProxyTenantInterfaceApi()
interfaceId = interfaceId_example # String |  (default to null)
tenantId = tenantId_example # String |  (default to null)
type = type_example # String | Limit by interfaceType (optional) (default to null)

try:
    api_response = api_instance.get_interface(interfaceId, tenantId, type=type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantInterfaceApi->getInterface: %s\n" % e)

extern crate ProxyTenantInterfaceApi;

pub fn main() {
    let interfaceId = interfaceId_example; // String
    let tenantId = tenantId_example; // String
    let type = type_example; // String

    let mut context = ProxyTenantInterfaceApi::Context::default();
    let result = client.getInterface(interfaceId, tenantId, type, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
interface_id*	String Required
tenant_id*	String Required

Query parameters

Name	Description
type	String Limit by interfaceType

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

ProxyTenantModule

disableTenantModule

Disable a module for a tenant. This call will eventually be replaced by the 'install' service.

/_/proxy/tenants/{tenant_id}/modules/{module_id}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/modules/{module_id}?invoke=invoke_example&purge=true&tenantParameters=tenantParameters_example"

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

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

public class ProxyTenantModuleApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantModuleApi apiInstance = new ProxyTenantModuleApi();
        String moduleId = moduleId_example; // String | 
        String tenantId = tenantId_example; // String | 
        String invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

        Boolean purge = true; // Boolean | Disabled modules will also be purged.
        String tenantParameters = tenantParameters_example; // String | Parameters for Tenant init

        try {
            apiInstance.disableTenantModule(moduleId, tenantId, invoke, purge, tenantParameters);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantModuleApi#disableTenantModule");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String moduleId = new String(); // String | 
final String tenantId = new String(); // String | 
final String invoke = new String(); // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

final Boolean purge = new Boolean(); // Boolean | Disabled modules will also be purged.
final String tenantParameters = new String(); // String | Parameters for Tenant init

try {
    final result = await api_instance.disableTenantModule(moduleId, tenantId, invoke, purge, tenantParameters);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->disableTenantModule: $e\n');
}

import org.openapitools.client.api.ProxyTenantModuleApi;

public class ProxyTenantModuleApiExample {
    public static void main(String[] args) {
        ProxyTenantModuleApi apiInstance = new ProxyTenantModuleApi();
        String moduleId = moduleId_example; // String | 
        String tenantId = tenantId_example; // String | 
        String invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

        Boolean purge = true; // Boolean | Disabled modules will also be purged.
        String tenantParameters = tenantParameters_example; // String | Parameters for Tenant init

        try {
            apiInstance.disableTenantModule(moduleId, tenantId, invoke, purge, tenantParameters);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantModuleApi#disableTenantModule");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantModuleApi *apiInstance = [[ProxyTenantModuleApi alloc] init];
String *moduleId = moduleId_example; //  (default to null)
String *tenantId = tenantId_example; //  (default to null)
String *invoke = invoke_example; // Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".
 (optional) (default to true)
Boolean *purge = true; // Disabled modules will also be purged. (optional) (default to false)
String *tenantParameters = tenantParameters_example; // Parameters for Tenant init (optional) (default to null)

[apiInstance disableTenantModuleWith:moduleId
    tenantId:tenantId
    invoke:invoke
    purge:purge
    tenantParameters:tenantParameters
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantModuleApi()
var moduleId = moduleId_example; // {String} 
var tenantId = tenantId_example; // {String} 
var opts = {
  'invoke': invoke_example, // {String} Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

  'purge': true, // {Boolean} Disabled modules will also be purged.
  'tenantParameters': tenantParameters_example // {String} Parameters for Tenant init
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantModuleApi();
            var moduleId = moduleId_example;  // String |  (default to null)
            var tenantId = tenantId_example;  // String |  (default to null)
            var invoke = invoke_example;  // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".
 (optional)  (default to true)
            var purge = true;  // Boolean | Disabled modules will also be purged. (optional)  (default to false)
            var tenantParameters = tenantParameters_example;  // String | Parameters for Tenant init (optional)  (default to null)

            try {
                apiInstance.disableTenantModule(moduleId, tenantId, invoke, purge, tenantParameters);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantModuleApi.disableTenantModule: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantModuleApi();
$moduleId = moduleId_example; // String | 
$tenantId = tenantId_example; // String | 
$invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

$purge = true; // Boolean | Disabled modules will also be purged.
$tenantParameters = tenantParameters_example; // String | Parameters for Tenant init

try {
    $api_instance->disableTenantModule($moduleId, $tenantId, $invoke, $purge, $tenantParameters);
} catch (Exception $e) {
    echo 'Exception when calling ProxyTenantModuleApi->disableTenantModule: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantModuleApi->new();
my $moduleId = moduleId_example; # String | 
my $tenantId = tenantId_example; # String | 
my $invoke = invoke_example; # String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

my $purge = true; # Boolean | Disabled modules will also be purged.
my $tenantParameters = tenantParameters_example; # String | Parameters for Tenant init

eval {
    $api_instance->disableTenantModule(moduleId => $moduleId, tenantId => $tenantId, invoke => $invoke, purge => $purge, tenantParameters => $tenantParameters);
};
if ($@) {
    warn "Exception when calling ProxyTenantModuleApi->disableTenantModule: $@\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.ProxyTenantModuleApi()
moduleId = moduleId_example # String |  (default to null)
tenantId = tenantId_example # String |  (default to null)
invoke = invoke_example # String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".
 (optional) (default to true)
purge = true # Boolean | Disabled modules will also be purged. (optional) (default to false)
tenantParameters = tenantParameters_example # String | Parameters for Tenant init (optional) (default to null)

try:
    api_instance.disable_tenant_module(moduleId, tenantId, invoke=invoke, purge=purge, tenantParameters=tenantParameters)
except ApiException as e:
    print("Exception when calling ProxyTenantModuleApi->disableTenantModule: %s\n" % e)

extern crate ProxyTenantModuleApi;

pub fn main() {
    let moduleId = moduleId_example; // String
    let tenantId = tenantId_example; // String
    let invoke = invoke_example; // String
    let purge = true; // Boolean
    let tenantParameters = tenantParameters_example; // String

    let mut context = ProxyTenantModuleApi::Context::default();
    let result = client.disableTenantModule(moduleId, tenantId, invoke, purge, tenantParameters, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
module_id*	String Required
tenant_id*	String Required

Query parameters

Name	Description
invoke	String Whether to invoke for tenant init/permissions/purge. Use "true" to invoke, "false" to not invoke. Any other value is a regular expression that is matched against the module ID. If that pattern matches, invoke is performed (same as "true)".
purge	Boolean Disabled modules will also be purged.
tenantParameters	String Parameters for Tenant init

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

disableTenantModules

Disable modules for tenant

/_/proxy/tenants/{tenant_id}/modules

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/modules?invoke=invoke_example&purge=true&tenantParameters=tenantParameters_example"

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

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

public class ProxyTenantModuleApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantModuleApi apiInstance = new ProxyTenantModuleApi();
        String tenantId = tenantId_example; // String | 
        String invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

        Boolean purge = true; // Boolean | Disabled modules will also be purged.
        String tenantParameters = tenantParameters_example; // String | Parameters for Tenant init

        try {
            apiInstance.disableTenantModules(tenantId, invoke, purge, tenantParameters);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantModuleApi#disableTenantModules");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 
final String invoke = new String(); // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

final Boolean purge = new Boolean(); // Boolean | Disabled modules will also be purged.
final String tenantParameters = new String(); // String | Parameters for Tenant init

try {
    final result = await api_instance.disableTenantModules(tenantId, invoke, purge, tenantParameters);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->disableTenantModules: $e\n');
}

import org.openapitools.client.api.ProxyTenantModuleApi;

public class ProxyTenantModuleApiExample {
    public static void main(String[] args) {
        ProxyTenantModuleApi apiInstance = new ProxyTenantModuleApi();
        String tenantId = tenantId_example; // String | 
        String invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

        Boolean purge = true; // Boolean | Disabled modules will also be purged.
        String tenantParameters = tenantParameters_example; // String | Parameters for Tenant init

        try {
            apiInstance.disableTenantModules(tenantId, invoke, purge, tenantParameters);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantModuleApi#disableTenantModules");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantModuleApi *apiInstance = [[ProxyTenantModuleApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)
String *invoke = invoke_example; // Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".
 (optional) (default to true)
Boolean *purge = true; // Disabled modules will also be purged. (optional) (default to false)
String *tenantParameters = tenantParameters_example; // Parameters for Tenant init (optional) (default to null)

[apiInstance disableTenantModulesWith:tenantId
    invoke:invoke
    purge:purge
    tenantParameters:tenantParameters
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantModuleApi()
var tenantId = tenantId_example; // {String} 
var opts = {
  'invoke': invoke_example, // {String} Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

  'purge': true, // {Boolean} Disabled modules will also be purged.
  'tenantParameters': tenantParameters_example // {String} Parameters for Tenant init
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantModuleApi();
            var tenantId = tenantId_example;  // String |  (default to null)
            var invoke = invoke_example;  // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".
 (optional)  (default to true)
            var purge = true;  // Boolean | Disabled modules will also be purged. (optional)  (default to false)
            var tenantParameters = tenantParameters_example;  // String | Parameters for Tenant init (optional)  (default to null)

            try {
                apiInstance.disableTenantModules(tenantId, invoke, purge, tenantParameters);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantModuleApi.disableTenantModules: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantModuleApi();
$tenantId = tenantId_example; // String | 
$invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

$purge = true; // Boolean | Disabled modules will also be purged.
$tenantParameters = tenantParameters_example; // String | Parameters for Tenant init

try {
    $api_instance->disableTenantModules($tenantId, $invoke, $purge, $tenantParameters);
} catch (Exception $e) {
    echo 'Exception when calling ProxyTenantModuleApi->disableTenantModules: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantModuleApi->new();
my $tenantId = tenantId_example; # String | 
my $invoke = invoke_example; # String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

my $purge = true; # Boolean | Disabled modules will also be purged.
my $tenantParameters = tenantParameters_example; # String | Parameters for Tenant init

eval {
    $api_instance->disableTenantModules(tenantId => $tenantId, invoke => $invoke, purge => $purge, tenantParameters => $tenantParameters);
};
if ($@) {
    warn "Exception when calling ProxyTenantModuleApi->disableTenantModules: $@\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.ProxyTenantModuleApi()
tenantId = tenantId_example # String |  (default to null)
invoke = invoke_example # String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".
 (optional) (default to true)
purge = true # Boolean | Disabled modules will also be purged. (optional) (default to false)
tenantParameters = tenantParameters_example # String | Parameters for Tenant init (optional) (default to null)

try:
    api_instance.disable_tenant_modules(tenantId, invoke=invoke, purge=purge, tenantParameters=tenantParameters)
except ApiException as e:
    print("Exception when calling ProxyTenantModuleApi->disableTenantModules: %s\n" % e)

extern crate ProxyTenantModuleApi;

pub fn main() {
    let tenantId = tenantId_example; // String
    let invoke = invoke_example; // String
    let purge = true; // Boolean
    let tenantParameters = tenantParameters_example; // String

    let mut context = ProxyTenantModuleApi::Context::default();
    let result = client.disableTenantModules(tenantId, invoke, purge, tenantParameters, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Query parameters

Name	Description
invoke	String Whether to invoke for tenant init/permissions/purge. Use "true" to invoke, "false" to not invoke. Any other value is a regular expression that is matched against the module ID. If that pattern matches, invoke is performed (same as "true)".
purge	Boolean Disabled modules will also be purged.
tenantParameters	String Parameters for Tenant init

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

enableTenantModule

Enable a module for tenant. Only the member 'id' from TenantModuleDescriptor is used in this operation. This call will eventually be replaced by the 'install' service.

/_/proxy/tenants/{tenant_id}/modules

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/modules" \
 -d '{
  "stage" : "pending",
  "action" : "enable",
  "from" : "from",
  "id" : "id",
  "message" : "message"
}'

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

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

public class ProxyTenantModuleApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantModuleApi apiInstance = new ProxyTenantModuleApi();
        String tenantId = tenantId_example; // String | 
        TenantModuleDescriptor tenantModuleDescriptor = ; // TenantModuleDescriptor | 

        try {
            TenantModuleDescriptor result = apiInstance.enableTenantModule(tenantId, tenantModuleDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantModuleApi#enableTenantModule");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 
final TenantModuleDescriptor tenantModuleDescriptor = new TenantModuleDescriptor(); // TenantModuleDescriptor | 

try {
    final result = await api_instance.enableTenantModule(tenantId, tenantModuleDescriptor);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->enableTenantModule: $e\n');
}

import org.openapitools.client.api.ProxyTenantModuleApi;

public class ProxyTenantModuleApiExample {
    public static void main(String[] args) {
        ProxyTenantModuleApi apiInstance = new ProxyTenantModuleApi();
        String tenantId = tenantId_example; // String | 
        TenantModuleDescriptor tenantModuleDescriptor = ; // TenantModuleDescriptor | 

        try {
            TenantModuleDescriptor result = apiInstance.enableTenantModule(tenantId, tenantModuleDescriptor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantModuleApi#enableTenantModule");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantModuleApi *apiInstance = [[ProxyTenantModuleApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)
TenantModuleDescriptor *tenantModuleDescriptor = ; // 

[apiInstance enableTenantModuleWith:tenantId
    tenantModuleDescriptor:tenantModuleDescriptor
              completionHandler: ^(TenantModuleDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantModuleApi()
var tenantId = tenantId_example; // {String} 
var tenantModuleDescriptor = ; // {TenantModuleDescriptor} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantModuleApi();
            var tenantId = tenantId_example;  // String |  (default to null)
            var tenantModuleDescriptor = new TenantModuleDescriptor(); // TenantModuleDescriptor | 

            try {
                TenantModuleDescriptor result = apiInstance.enableTenantModule(tenantId, tenantModuleDescriptor);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantModuleApi.enableTenantModule: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantModuleApi();
$tenantId = tenantId_example; // String | 
$tenantModuleDescriptor = ; // TenantModuleDescriptor | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantModuleApi->new();
my $tenantId = tenantId_example; # String | 
my $tenantModuleDescriptor = WWW::OPenAPIClient::Object::TenantModuleDescriptor->new(); # TenantModuleDescriptor | 

eval {
    my $result = $api_instance->enableTenantModule(tenantId => $tenantId, tenantModuleDescriptor => $tenantModuleDescriptor);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantModuleApi->enableTenantModule: $@\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.ProxyTenantModuleApi()
tenantId = tenantId_example # String |  (default to null)
tenantModuleDescriptor =  # TenantModuleDescriptor | 

try:
    api_response = api_instance.enable_tenant_module(tenantId, tenantModuleDescriptor)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantModuleApi->enableTenantModule: %s\n" % e)

extern crate ProxyTenantModuleApi;

pub fn main() {
    let tenantId = tenantId_example; // String
    let tenantModuleDescriptor = ; // TenantModuleDescriptor

    let mut context = ProxyTenantModuleApi::Context::default();
    let result = client.enableTenantModule(tenantId, tenantModuleDescriptor, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Body parameters

Name	Description
tenantModuleDescriptor *

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String
Location	String		URI to the environment entry instance

getAllTenantModules

Get enabled modules for tenant

/_/proxy/tenants/{tenant_id}/modules

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/modules?dot=true&filter=filter_example&full=true&latest=56&order=order_example&orderBy=orderBy_example&provide=provide_example&require=require_example&scope=scope_example&preRelease=preRelease_example&npmSnapshot=npmSnapshot_example"

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

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

public class ProxyTenantModuleApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantModuleApi apiInstance = new ProxyTenantModuleApi();
        String tenantId = tenantId_example; // String | 
        Boolean dot = true; // Boolean | If true, return Graphviz DOT content as plain text
        String filter = filter_example; // String | Filter by module ID
        Boolean full = true; // Boolean | Whether full or compact MD should be returned
        Integer latest = 56; // Integer | Limit to latest N releases (most likely 1 if given)
        String order = order_example; // String | Order
        String orderBy = orderBy_example; // String | Order by field
        String provide = provide_example; // String | Limit to provided interfaces (each interface name separated by comma)
        String require = require_example; // String | Limit to required interfaces (each interface name separted by comma)
        String scope = scope_example; // String | Limit to interface scope (only useful with provide and require)
        String preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
        String npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

        try {
            array[ModuleDescriptor] result = apiInstance.getAllTenantModules(tenantId, dot, filter, full, latest, order, orderBy, provide, require, scope, preRelease, npmSnapshot);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantModuleApi#getAllTenantModules");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 
final Boolean dot = new Boolean(); // Boolean | If true, return Graphviz DOT content as plain text
final String filter = new String(); // String | Filter by module ID
final Boolean full = new Boolean(); // Boolean | Whether full or compact MD should be returned
final Integer latest = new Integer(); // Integer | Limit to latest N releases (most likely 1 if given)
final String order = new String(); // String | Order
final String orderBy = new String(); // String | Order by field
final String provide = new String(); // String | Limit to provided interfaces (each interface name separated by comma)
final String require = new String(); // String | Limit to required interfaces (each interface name separted by comma)
final String scope = new String(); // String | Limit to interface scope (only useful with provide and require)
final String preRelease = new String(); // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
final String npmSnapshot = new String(); // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

try {
    final result = await api_instance.getAllTenantModules(tenantId, dot, filter, full, latest, order, orderBy, provide, require, scope, preRelease, npmSnapshot);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllTenantModules: $e\n');
}

import org.openapitools.client.api.ProxyTenantModuleApi;

public class ProxyTenantModuleApiExample {
    public static void main(String[] args) {
        ProxyTenantModuleApi apiInstance = new ProxyTenantModuleApi();
        String tenantId = tenantId_example; // String | 
        Boolean dot = true; // Boolean | If true, return Graphviz DOT content as plain text
        String filter = filter_example; // String | Filter by module ID
        Boolean full = true; // Boolean | Whether full or compact MD should be returned
        Integer latest = 56; // Integer | Limit to latest N releases (most likely 1 if given)
        String order = order_example; // String | Order
        String orderBy = orderBy_example; // String | Order by field
        String provide = provide_example; // String | Limit to provided interfaces (each interface name separated by comma)
        String require = require_example; // String | Limit to required interfaces (each interface name separted by comma)
        String scope = scope_example; // String | Limit to interface scope (only useful with provide and require)
        String preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
        String npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

        try {
            array[ModuleDescriptor] result = apiInstance.getAllTenantModules(tenantId, dot, filter, full, latest, order, orderBy, provide, require, scope, preRelease, npmSnapshot);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantModuleApi#getAllTenantModules");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantModuleApi *apiInstance = [[ProxyTenantModuleApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)
Boolean *dot = true; // If true, return Graphviz DOT content as plain text (optional) (default to false)
String *filter = filter_example; // Filter by module ID (optional) (default to null)
Boolean *full = true; // Whether full or compact MD should be returned (optional) (default to false)
Integer *latest = 56; // Limit to latest N releases (most likely 1 if given) (optional) (default to null)
String *order = order_example; // Order (optional) (default to null)
String *orderBy = orderBy_example; // Order by field (optional) (default to null)
String *provide = provide_example; // Limit to provided interfaces (each interface name separated by comma) (optional) (default to null)
String *require = require_example; // Limit to required interfaces (each interface name separted by comma) (optional) (default to null)
String *scope = scope_example; // Limit to interface scope (only useful with provide and require) (optional) (default to null)
String *preRelease = preRelease_example; // Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional) (default to true)
String *npmSnapshot = npmSnapshot_example; // Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional) (default to true)

[apiInstance getAllTenantModulesWith:tenantId
    dot:dot
    filter:filter
    full:full
    latest:latest
    order:order
    orderBy:orderBy
    provide:provide
    require:require
    scope:scope
    preRelease:preRelease
    npmSnapshot:npmSnapshot
              completionHandler: ^(array[ModuleDescriptor] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantModuleApi()
var tenantId = tenantId_example; // {String} 
var opts = {
  'dot': true, // {Boolean} If true, return Graphviz DOT content as plain text
  'filter': filter_example, // {String} Filter by module ID
  'full': true, // {Boolean} Whether full or compact MD should be returned
  'latest': 56, // {Integer} Limit to latest N releases (most likely 1 if given)
  'order': order_example, // {String} Order
  'orderBy': orderBy_example, // {String} Order by field
  'provide': provide_example, // {String} Limit to provided interfaces (each interface name separated by comma)
  'require': require_example, // {String} Limit to required interfaces (each interface name separted by comma)
  'scope': scope_example, // {String} Limit to interface scope (only useful with provide and require)
  'preRelease': preRelease_example, // {String} Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
  'npmSnapshot': npmSnapshot_example // {String} Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantModuleApi();
            var tenantId = tenantId_example;  // String |  (default to null)
            var dot = true;  // Boolean | If true, return Graphviz DOT content as plain text (optional)  (default to false)
            var filter = filter_example;  // String | Filter by module ID (optional)  (default to null)
            var full = true;  // Boolean | Whether full or compact MD should be returned (optional)  (default to false)
            var latest = 56;  // Integer | Limit to latest N releases (most likely 1 if given) (optional)  (default to null)
            var order = order_example;  // String | Order (optional)  (default to null)
            var orderBy = orderBy_example;  // String | Order by field (optional)  (default to null)
            var provide = provide_example;  // String | Limit to provided interfaces (each interface name separated by comma) (optional)  (default to null)
            var require = require_example;  // String | Limit to required interfaces (each interface name separted by comma) (optional)  (default to null)
            var scope = scope_example;  // String | Limit to interface scope (only useful with provide and require) (optional)  (default to null)
            var preRelease = preRelease_example;  // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional)  (default to true)
            var npmSnapshot = npmSnapshot_example;  // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional)  (default to true)

            try {
                array[ModuleDescriptor] result = apiInstance.getAllTenantModules(tenantId, dot, filter, full, latest, order, orderBy, provide, require, scope, preRelease, npmSnapshot);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantModuleApi.getAllTenantModules: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantModuleApi();
$tenantId = tenantId_example; // String | 
$dot = true; // Boolean | If true, return Graphviz DOT content as plain text
$filter = filter_example; // String | Filter by module ID
$full = true; // Boolean | Whether full or compact MD should be returned
$latest = 56; // Integer | Limit to latest N releases (most likely 1 if given)
$order = order_example; // String | Order
$orderBy = orderBy_example; // String | Order by field
$provide = provide_example; // String | Limit to provided interfaces (each interface name separated by comma)
$require = require_example; // String | Limit to required interfaces (each interface name separted by comma)
$scope = scope_example; // String | Limit to interface scope (only useful with provide and require)
$preRelease = preRelease_example; // String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
$npmSnapshot = npmSnapshot_example; // String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

try {
    $result = $api_instance->getAllTenantModules($tenantId, $dot, $filter, $full, $latest, $order, $orderBy, $provide, $require, $scope, $preRelease, $npmSnapshot);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyTenantModuleApi->getAllTenantModules: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantModuleApi->new();
my $tenantId = tenantId_example; # String | 
my $dot = true; # Boolean | If true, return Graphviz DOT content as plain text
my $filter = filter_example; # String | Filter by module ID
my $full = true; # Boolean | Whether full or compact MD should be returned
my $latest = 56; # Integer | Limit to latest N releases (most likely 1 if given)
my $order = order_example; # String | Order
my $orderBy = orderBy_example; # String | Order by field
my $provide = provide_example; # String | Limit to provided interfaces (each interface name separated by comma)
my $require = require_example; # String | Limit to required interfaces (each interface name separted by comma)
my $scope = scope_example; # String | Limit to interface scope (only useful with provide and require)
my $preRelease = preRelease_example; # String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
my $npmSnapshot = npmSnapshot_example; # String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

eval {
    my $result = $api_instance->getAllTenantModules(tenantId => $tenantId, dot => $dot, filter => $filter, full => $full, latest => $latest, order => $order, orderBy => $orderBy, provide => $provide, require => $require, scope => $scope, preRelease => $preRelease, npmSnapshot => $npmSnapshot);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantModuleApi->getAllTenantModules: $@\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.ProxyTenantModuleApi()
tenantId = tenantId_example # String |  (default to null)
dot = true # Boolean | If true, return Graphviz DOT content as plain text (optional) (default to false)
filter = filter_example # String | Filter by module ID (optional) (default to null)
full = true # Boolean | Whether full or compact MD should be returned (optional) (default to false)
latest = 56 # Integer | Limit to latest N releases (most likely 1 if given) (optional) (default to null)
order = order_example # String | Order (optional) (default to null)
orderBy = orderBy_example # String | Order by field (optional) (default to null)
provide = provide_example # String | Limit to provided interfaces (each interface name separated by comma) (optional) (default to null)
require = require_example # String | Limit to required interfaces (each interface name separted by comma) (optional) (default to null)
scope = scope_example # String | Limit to interface scope (only useful with provide and require) (optional) (default to null)
preRelease = preRelease_example # String | Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases. (optional) (default to true)
npmSnapshot = npmSnapshot_example # String | Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots. (optional) (default to true)

try:
    api_response = api_instance.get_all_tenant_modules(tenantId, dot=dot, filter=filter, full=full, latest=latest, order=order, orderBy=orderBy, provide=provide, require=require, scope=scope, preRelease=preRelease, npmSnapshot=npmSnapshot)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantModuleApi->getAllTenantModules: %s\n" % e)

extern crate ProxyTenantModuleApi;

pub fn main() {
    let tenantId = tenantId_example; // String
    let dot = true; // Boolean
    let filter = filter_example; // String
    let full = true; // Boolean
    let latest = 56; // Integer
    let order = order_example; // String
    let orderBy = orderBy_example; // String
    let provide = provide_example; // String
    let require = require_example; // String
    let scope = scope_example; // String
    let preRelease = preRelease_example; // String
    let npmSnapshot = npmSnapshot_example; // String

    let mut context = ProxyTenantModuleApi::Context::default();
    let result = client.getAllTenantModules(tenantId, dot, filter, full, latest, order, orderBy, provide, require, scope, preRelease, npmSnapshot, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Query parameters

Name	Description
dot	Boolean If true, return Graphviz DOT content as plain text
filter	String Filter by module ID
full	Boolean Whether full or compact MD should be returned
latest	Integer Limit to latest N releases (most likely 1 if given)
order	String Order
orderBy	String Order by field
provide	String Limit to provided interfaces (each interface name separated by comma)
require	String Limit to required interfaces (each interface name separted by comma)
scope	String Limit to interface scope (only useful with provide and require)
preRelease	String Whether to use pre-release in operation. "true": use all modules; "false": releases (no pre-releases); "only": only pre-releases.
npmSnapshot	String Whether to use NPM module snapshots in operation. "true": use all modules; "false": releases (no NPM snapshots); "only": only NPM snapshots.

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getTenantModule

Look up particular module selection

/_/proxy/tenants/{tenant_id}/modules/{module_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/modules/{module_id}"

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

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

public class ProxyTenantModuleApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantModuleApi apiInstance = new ProxyTenantModuleApi();
        String moduleId = moduleId_example; // String | 
        String tenantId = tenantId_example; // String | 

        try {
            TenantModuleDescriptor result = apiInstance.getTenantModule(moduleId, tenantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantModuleApi#getTenantModule");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String moduleId = new String(); // String | 
final String tenantId = new String(); // String | 

try {
    final result = await api_instance.getTenantModule(moduleId, tenantId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getTenantModule: $e\n');
}

import org.openapitools.client.api.ProxyTenantModuleApi;

public class ProxyTenantModuleApiExample {
    public static void main(String[] args) {
        ProxyTenantModuleApi apiInstance = new ProxyTenantModuleApi();
        String moduleId = moduleId_example; // String | 
        String tenantId = tenantId_example; // String | 

        try {
            TenantModuleDescriptor result = apiInstance.getTenantModule(moduleId, tenantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantModuleApi#getTenantModule");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantModuleApi *apiInstance = [[ProxyTenantModuleApi alloc] init];
String *moduleId = moduleId_example; //  (default to null)
String *tenantId = tenantId_example; //  (default to null)

[apiInstance getTenantModuleWith:moduleId
    tenantId:tenantId
              completionHandler: ^(TenantModuleDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantModuleApi()
var moduleId = moduleId_example; // {String} 
var tenantId = tenantId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantModuleApi();
            var moduleId = moduleId_example;  // String |  (default to null)
            var tenantId = tenantId_example;  // String |  (default to null)

            try {
                TenantModuleDescriptor result = apiInstance.getTenantModule(moduleId, tenantId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantModuleApi.getTenantModule: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantModuleApi();
$moduleId = moduleId_example; // String | 
$tenantId = tenantId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantModuleApi->new();
my $moduleId = moduleId_example; # String | 
my $tenantId = tenantId_example; # String | 

eval {
    my $result = $api_instance->getTenantModule(moduleId => $moduleId, tenantId => $tenantId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantModuleApi->getTenantModule: $@\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.ProxyTenantModuleApi()
moduleId = moduleId_example # String |  (default to null)
tenantId = tenantId_example # String |  (default to null)

try:
    api_response = api_instance.get_tenant_module(moduleId, tenantId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantModuleApi->getTenantModule: %s\n" % e)

extern crate ProxyTenantModuleApi;

pub fn main() {
    let moduleId = moduleId_example; // String
    let tenantId = tenantId_example; // String

    let mut context = ProxyTenantModuleApi::Context::default();
    let result = client.getTenantModule(moduleId, tenantId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
module_id*	String Required
tenant_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

upgradeTenantModule

Upgrade a module for a tenant. Enable new module and disable current module with new module ID in body and existing ID in path. This call will eventually be replaced by the 'install' service.

/_/proxy/tenants/{tenant_id}/modules/{module_id}

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/modules/{module_id}?invoke=invoke_example&purge=true&tenantParameters=tenantParameters_example" \
 -d '{
  "stage" : "pending",
  "action" : "enable",
  "from" : "from",
  "id" : "id",
  "message" : "message"
}'

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

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

public class ProxyTenantModuleApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantModuleApi apiInstance = new ProxyTenantModuleApi();
        String moduleId = moduleId_example; // String | 
        String tenantId = tenantId_example; // String | 
        TenantModuleDescriptor tenantModuleDescriptor = ; // TenantModuleDescriptor | 
        String invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

        Boolean purge = true; // Boolean | Disabled modules will also be purged.
        String tenantParameters = tenantParameters_example; // String | Parameters for Tenant init

        try {
            TenantModuleDescriptor result = apiInstance.upgradeTenantModule(moduleId, tenantId, tenantModuleDescriptor, invoke, purge, tenantParameters);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantModuleApi#upgradeTenantModule");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String moduleId = new String(); // String | 
final String tenantId = new String(); // String | 
final TenantModuleDescriptor tenantModuleDescriptor = new TenantModuleDescriptor(); // TenantModuleDescriptor | 
final String invoke = new String(); // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

final Boolean purge = new Boolean(); // Boolean | Disabled modules will also be purged.
final String tenantParameters = new String(); // String | Parameters for Tenant init

try {
    final result = await api_instance.upgradeTenantModule(moduleId, tenantId, tenantModuleDescriptor, invoke, purge, tenantParameters);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->upgradeTenantModule: $e\n');
}

import org.openapitools.client.api.ProxyTenantModuleApi;

public class ProxyTenantModuleApiExample {
    public static void main(String[] args) {
        ProxyTenantModuleApi apiInstance = new ProxyTenantModuleApi();
        String moduleId = moduleId_example; // String | 
        String tenantId = tenantId_example; // String | 
        TenantModuleDescriptor tenantModuleDescriptor = ; // TenantModuleDescriptor | 
        String invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

        Boolean purge = true; // Boolean | Disabled modules will also be purged.
        String tenantParameters = tenantParameters_example; // String | Parameters for Tenant init

        try {
            TenantModuleDescriptor result = apiInstance.upgradeTenantModule(moduleId, tenantId, tenantModuleDescriptor, invoke, purge, tenantParameters);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantModuleApi#upgradeTenantModule");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantModuleApi *apiInstance = [[ProxyTenantModuleApi alloc] init];
String *moduleId = moduleId_example; //  (default to null)
String *tenantId = tenantId_example; //  (default to null)
TenantModuleDescriptor *tenantModuleDescriptor = ; // 
String *invoke = invoke_example; // Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".
 (optional) (default to true)
Boolean *purge = true; // Disabled modules will also be purged. (optional) (default to false)
String *tenantParameters = tenantParameters_example; // Parameters for Tenant init (optional) (default to null)

[apiInstance upgradeTenantModuleWith:moduleId
    tenantId:tenantId
    tenantModuleDescriptor:tenantModuleDescriptor
    invoke:invoke
    purge:purge
    tenantParameters:tenantParameters
              completionHandler: ^(TenantModuleDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantModuleApi()
var moduleId = moduleId_example; // {String} 
var tenantId = tenantId_example; // {String} 
var tenantModuleDescriptor = ; // {TenantModuleDescriptor} 
var opts = {
  'invoke': invoke_example, // {String} Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

  'purge': true, // {Boolean} Disabled modules will also be purged.
  'tenantParameters': tenantParameters_example // {String} Parameters for Tenant init
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantModuleApi();
            var moduleId = moduleId_example;  // String |  (default to null)
            var tenantId = tenantId_example;  // String |  (default to null)
            var tenantModuleDescriptor = new TenantModuleDescriptor(); // TenantModuleDescriptor | 
            var invoke = invoke_example;  // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".
 (optional)  (default to true)
            var purge = true;  // Boolean | Disabled modules will also be purged. (optional)  (default to false)
            var tenantParameters = tenantParameters_example;  // String | Parameters for Tenant init (optional)  (default to null)

            try {
                TenantModuleDescriptor result = apiInstance.upgradeTenantModule(moduleId, tenantId, tenantModuleDescriptor, invoke, purge, tenantParameters);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantModuleApi.upgradeTenantModule: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantModuleApi();
$moduleId = moduleId_example; // String | 
$tenantId = tenantId_example; // String | 
$tenantModuleDescriptor = ; // TenantModuleDescriptor | 
$invoke = invoke_example; // String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

$purge = true; // Boolean | Disabled modules will also be purged.
$tenantParameters = tenantParameters_example; // String | Parameters for Tenant init

try {
    $result = $api_instance->upgradeTenantModule($moduleId, $tenantId, $tenantModuleDescriptor, $invoke, $purge, $tenantParameters);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyTenantModuleApi->upgradeTenantModule: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantModuleApi->new();
my $moduleId = moduleId_example; # String | 
my $tenantId = tenantId_example; # String | 
my $tenantModuleDescriptor = WWW::OPenAPIClient::Object::TenantModuleDescriptor->new(); # TenantModuleDescriptor | 
my $invoke = invoke_example; # String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".

my $purge = true; # Boolean | Disabled modules will also be purged.
my $tenantParameters = tenantParameters_example; # String | Parameters for Tenant init

eval {
    my $result = $api_instance->upgradeTenantModule(moduleId => $moduleId, tenantId => $tenantId, tenantModuleDescriptor => $tenantModuleDescriptor, invoke => $invoke, purge => $purge, tenantParameters => $tenantParameters);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantModuleApi->upgradeTenantModule: $@\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.ProxyTenantModuleApi()
moduleId = moduleId_example # String |  (default to null)
tenantId = tenantId_example # String |  (default to null)
tenantModuleDescriptor =  # TenantModuleDescriptor | 
invoke = invoke_example # String | Whether to invoke for tenant init/permissions/purge. Use
"true" to invoke, "false" to not invoke. Any other value
is a regular expression that is matched against the module ID.
If that pattern matches, invoke is performed (same as "true)".
 (optional) (default to true)
purge = true # Boolean | Disabled modules will also be purged. (optional) (default to false)
tenantParameters = tenantParameters_example # String | Parameters for Tenant init (optional) (default to null)

try:
    api_response = api_instance.upgrade_tenant_module(moduleId, tenantId, tenantModuleDescriptor, invoke=invoke, purge=purge, tenantParameters=tenantParameters)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantModuleApi->upgradeTenantModule: %s\n" % e)

extern crate ProxyTenantModuleApi;

pub fn main() {
    let moduleId = moduleId_example; // String
    let tenantId = tenantId_example; // String
    let tenantModuleDescriptor = ; // TenantModuleDescriptor
    let invoke = invoke_example; // String
    let purge = true; // Boolean
    let tenantParameters = tenantParameters_example; // String

    let mut context = ProxyTenantModuleApi::Context::default();
    let result = client.upgradeTenantModule(moduleId, tenantId, tenantModuleDescriptor, invoke, purge, tenantParameters, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
module_id*	String Required
tenant_id*	String Required

Body parameters

Name	Description
tenantModuleDescriptor *

Query parameters

Name	Description
invoke	String Whether to invoke for tenant init/permissions/purge. Use "true" to invoke, "false" to not invoke. Any other value is a regular expression that is matched against the module ID. If that pattern matches, invoke is performed (same as "true)".
purge	Boolean Disabled modules will also be purged.
tenantParameters	String Parameters for Tenant init

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String
Location	String		URI to the environment entry instance

ProxyTenantTimer

getAllTimers

Get timers for tenant.

/_/proxy/tenants/{tenant_id}/timers

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/timers"

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

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

public class ProxyTenantTimerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantTimerApi apiInstance = new ProxyTenantTimerApi();
        String tenantId = tenantId_example; // String | 

        try {
            array[TimerDescriptor] result = apiInstance.getAllTimers(tenantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantTimerApi#getAllTimers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 

try {
    final result = await api_instance.getAllTimers(tenantId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllTimers: $e\n');
}

import org.openapitools.client.api.ProxyTenantTimerApi;

public class ProxyTenantTimerApiExample {
    public static void main(String[] args) {
        ProxyTenantTimerApi apiInstance = new ProxyTenantTimerApi();
        String tenantId = tenantId_example; // String | 

        try {
            array[TimerDescriptor] result = apiInstance.getAllTimers(tenantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantTimerApi#getAllTimers");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantTimerApi *apiInstance = [[ProxyTenantTimerApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)

[apiInstance getAllTimersWith:tenantId
              completionHandler: ^(array[TimerDescriptor] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantTimerApi()
var tenantId = tenantId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantTimerApi();
            var tenantId = tenantId_example;  // String |  (default to null)

            try {
                array[TimerDescriptor] result = apiInstance.getAllTimers(tenantId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantTimerApi.getAllTimers: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantTimerApi();
$tenantId = tenantId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantTimerApi->new();
my $tenantId = tenantId_example; # String | 

eval {
    my $result = $api_instance->getAllTimers(tenantId => $tenantId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantTimerApi->getAllTimers: $@\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.ProxyTenantTimerApi()
tenantId = tenantId_example # String |  (default to null)

try:
    api_response = api_instance.get_all_timers(tenantId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantTimerApi->getAllTimers: %s\n" % e)

extern crate ProxyTenantTimerApi;

pub fn main() {
    let tenantId = tenantId_example; // String

    let mut context = ProxyTenantTimerApi::Context::default();
    let result = client.getAllTimers(tenantId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

getTimer

get timer with id given.

/_/proxy/tenants/{tenant_id}/timers/{timer_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/timers/{timer_id}"

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

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

public class ProxyTenantTimerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantTimerApi apiInstance = new ProxyTenantTimerApi();
        String timerId = timerId_example; // String | 
        String tenantId = tenantId_example; // String | 

        try {
            TimerDescriptor result = apiInstance.getTimer(timerId, tenantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantTimerApi#getTimer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String timerId = new String(); // String | 
final String tenantId = new String(); // String | 

try {
    final result = await api_instance.getTimer(timerId, tenantId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getTimer: $e\n');
}

import org.openapitools.client.api.ProxyTenantTimerApi;

public class ProxyTenantTimerApiExample {
    public static void main(String[] args) {
        ProxyTenantTimerApi apiInstance = new ProxyTenantTimerApi();
        String timerId = timerId_example; // String | 
        String tenantId = tenantId_example; // String | 

        try {
            TimerDescriptor result = apiInstance.getTimer(timerId, tenantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantTimerApi#getTimer");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantTimerApi *apiInstance = [[ProxyTenantTimerApi alloc] init];
String *timerId = timerId_example; //  (default to null)
String *tenantId = tenantId_example; //  (default to null)

[apiInstance getTimerWith:timerId
    tenantId:tenantId
              completionHandler: ^(TimerDescriptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantTimerApi()
var timerId = timerId_example; // {String} 
var tenantId = tenantId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantTimerApi();
            var timerId = timerId_example;  // String |  (default to null)
            var tenantId = tenantId_example;  // String |  (default to null)

            try {
                TimerDescriptor result = apiInstance.getTimer(timerId, tenantId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantTimerApi.getTimer: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantTimerApi();
$timerId = timerId_example; // String | 
$tenantId = tenantId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantTimerApi->new();
my $timerId = timerId_example; # String | 
my $tenantId = tenantId_example; # String | 

eval {
    my $result = $api_instance->getTimer(timerId => $timerId, tenantId => $tenantId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyTenantTimerApi->getTimer: $@\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.ProxyTenantTimerApi()
timerId = timerId_example # String |  (default to null)
tenantId = tenantId_example # String |  (default to null)

try:
    api_response = api_instance.get_timer(timerId, tenantId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyTenantTimerApi->getTimer: %s\n" % e)

extern crate ProxyTenantTimerApi;

pub fn main() {
    let timerId = timerId_example; // String
    let tenantId = tenantId_example; // String

    let mut context = ProxyTenantTimerApi::Context::default();
    let result = client.getTimer(timerId, tenantId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
timer_id*	String Required
tenant_id*	String Required

Responses

Schema
Headers

Name	Type	Format	Description
X-Okapi-Trace	String

updateTimer

patch timer with routing entry as body. The unit, delay and schedule determines the new schedule for the timer. Using delay=0 disables a timer. Omitting delay, unit and schedule reverts timer back to initial values from module.

/_/proxy/tenants/{tenant_id}/timers/{timer_id}

Usage and SDK Samples

curl -X PATCH \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/timers/{timer_id}" \
 -d '{
  "phase" : "phase",
  "permissionsDesired" : [ "permissionsDesired", "permissionsDesired" ],
  "delegateCORS" : true,
  "level" : "level",
  "methods" : [ "methods", "methods" ],
  "modulePermissions" : [ "modulePermissions", "modulePermissions" ],
  "redirectPath" : "redirectPath",
  "type" : "type",
  "rewritePath" : "rewritePath",
  "permissionsRequired" : [ "permissionsRequired", "permissionsRequired" ],
  "path" : "path",
  "schedule" : {
    "cron" : "cron",
    "zone" : "zone"
  },
  "unit" : "unit",
  "permissionsRequiredTenant" : [ "permissionsRequiredTenant", "permissionsRequiredTenant" ],
  "delay" : "delay",
  "pathPattern" : "pathPattern"
}'

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

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

public class ProxyTenantTimerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantTimerApi apiInstance = new ProxyTenantTimerApi();
        String timerId = timerId_example; // String | 
        String tenantId = tenantId_example; // String | 
        RoutingEntry routingEntry = ; // RoutingEntry | 

        try {
            apiInstance.updateTimer(timerId, tenantId, routingEntry);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantTimerApi#updateTimer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String timerId = new String(); // String | 
final String tenantId = new String(); // String | 
final RoutingEntry routingEntry = new RoutingEntry(); // RoutingEntry | 

try {
    final result = await api_instance.updateTimer(timerId, tenantId, routingEntry);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateTimer: $e\n');
}

import org.openapitools.client.api.ProxyTenantTimerApi;

public class ProxyTenantTimerApiExample {
    public static void main(String[] args) {
        ProxyTenantTimerApi apiInstance = new ProxyTenantTimerApi();
        String timerId = timerId_example; // String | 
        String tenantId = tenantId_example; // String | 
        RoutingEntry routingEntry = ; // RoutingEntry | 

        try {
            apiInstance.updateTimer(timerId, tenantId, routingEntry);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantTimerApi#updateTimer");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantTimerApi *apiInstance = [[ProxyTenantTimerApi alloc] init];
String *timerId = timerId_example; //  (default to null)
String *tenantId = tenantId_example; //  (default to null)
RoutingEntry *routingEntry = ; // 

[apiInstance updateTimerWith:timerId
    tenantId:tenantId
    routingEntry:routingEntry
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantTimerApi()
var timerId = timerId_example; // {String} 
var tenantId = tenantId_example; // {String} 
var routingEntry = ; // {RoutingEntry} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantTimerApi();
            var timerId = timerId_example;  // String |  (default to null)
            var tenantId = tenantId_example;  // String |  (default to null)
            var routingEntry = new RoutingEntry(); // RoutingEntry | 

            try {
                apiInstance.updateTimer(timerId, tenantId, routingEntry);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantTimerApi.updateTimer: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantTimerApi();
$timerId = timerId_example; // String | 
$tenantId = tenantId_example; // String | 
$routingEntry = ; // RoutingEntry | 

try {
    $api_instance->updateTimer($timerId, $tenantId, $routingEntry);
} catch (Exception $e) {
    echo 'Exception when calling ProxyTenantTimerApi->updateTimer: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantTimerApi->new();
my $timerId = timerId_example; # String | 
my $tenantId = tenantId_example; # String | 
my $routingEntry = WWW::OPenAPIClient::Object::RoutingEntry->new(); # RoutingEntry | 

eval {
    $api_instance->updateTimer(timerId => $timerId, tenantId => $tenantId, routingEntry => $routingEntry);
};
if ($@) {
    warn "Exception when calling ProxyTenantTimerApi->updateTimer: $@\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.ProxyTenantTimerApi()
timerId = timerId_example # String |  (default to null)
tenantId = tenantId_example # String |  (default to null)
routingEntry =  # RoutingEntry | 

try:
    api_instance.update_timer(timerId, tenantId, routingEntry)
except ApiException as e:
    print("Exception when calling ProxyTenantTimerApi->updateTimer: %s\n" % e)

extern crate ProxyTenantTimerApi;

pub fn main() {
    let timerId = timerId_example; // String
    let tenantId = tenantId_example; // String
    let routingEntry = ; // RoutingEntry

    let mut context = ProxyTenantTimerApi::Context::default();
    let result = client.updateTimer(timerId, tenantId, routingEntry, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
timer_id*	String Required
tenant_id*	String Required

Body parameters

Name	Description
routingEntry *

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

updateTimers

patch timer. Both routingEntry and id must be given. The routingEntry.unit, routingEntry.delay and routingEntry.schedule determines the new schedule for the timer. Using delay=0 disables a timer. Omitting delay, unit and schedule reverts timer back to initial values from module.

/_/proxy/tenants/{tenant_id}/timers

Usage and SDK Samples

curl -X PATCH \
 -H "Content-Type: application/json" \
 "http://localhost:8081/_/proxy/tenants/{tenant_id}/timers" \
 -d '{
  "routingEntry" : {
    "phase" : "phase",
    "permissionsDesired" : [ "permissionsDesired", "permissionsDesired" ],
    "delegateCORS" : true,
    "level" : "level",
    "methods" : [ "methods", "methods" ],
    "modulePermissions" : [ "modulePermissions", "modulePermissions" ],
    "redirectPath" : "redirectPath",
    "type" : "type",
    "rewritePath" : "rewritePath",
    "permissionsRequired" : [ "permissionsRequired", "permissionsRequired" ],
    "path" : "path",
    "schedule" : {
      "cron" : "cron",
      "zone" : "zone"
    },
    "unit" : "unit",
    "permissionsRequiredTenant" : [ "permissionsRequiredTenant", "permissionsRequiredTenant" ],
    "delay" : "delay",
    "pathPattern" : "pathPattern"
  },
  "modified" : true,
  "id" : "id"
}'

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

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

public class ProxyTenantTimerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProxyTenantTimerApi apiInstance = new ProxyTenantTimerApi();
        String tenantId = tenantId_example; // String | 
        TimerDescriptor timerDescriptor = ; // TimerDescriptor | 

        try {
            apiInstance.updateTimers(tenantId, timerDescriptor);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantTimerApi#updateTimers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tenantId = new String(); // String | 
final TimerDescriptor timerDescriptor = new TimerDescriptor(); // TimerDescriptor | 

try {
    final result = await api_instance.updateTimers(tenantId, timerDescriptor);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateTimers: $e\n');
}

import org.openapitools.client.api.ProxyTenantTimerApi;

public class ProxyTenantTimerApiExample {
    public static void main(String[] args) {
        ProxyTenantTimerApi apiInstance = new ProxyTenantTimerApi();
        String tenantId = tenantId_example; // String | 
        TimerDescriptor timerDescriptor = ; // TimerDescriptor | 

        try {
            apiInstance.updateTimers(tenantId, timerDescriptor);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyTenantTimerApi#updateTimers");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProxyTenantTimerApi *apiInstance = [[ProxyTenantTimerApi alloc] init];
String *tenantId = tenantId_example; //  (default to null)
TimerDescriptor *timerDescriptor = ; // 

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

// Create an instance of the API class
var api = new OkapiCoreApiFacade.ProxyTenantTimerApi()
var tenantId = tenantId_example; // {String} 
var timerDescriptor = ; // {TimerDescriptor} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProxyTenantTimerApi();
            var tenantId = tenantId_example;  // String |  (default to null)
            var timerDescriptor = new TimerDescriptor(); // TimerDescriptor | 

            try {
                apiInstance.updateTimers(tenantId, timerDescriptor);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyTenantTimerApi.updateTimers: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyTenantTimerApi();
$tenantId = tenantId_example; // String | 
$timerDescriptor = ; // TimerDescriptor | 

try {
    $api_instance->updateTimers($tenantId, $timerDescriptor);
} catch (Exception $e) {
    echo 'Exception when calling ProxyTenantTimerApi->updateTimers: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyTenantTimerApi->new();
my $tenantId = tenantId_example; # String | 
my $timerDescriptor = WWW::OPenAPIClient::Object::TimerDescriptor->new(); # TimerDescriptor | 

eval {
    $api_instance->updateTimers(tenantId => $tenantId, timerDescriptor => $timerDescriptor);
};
if ($@) {
    warn "Exception when calling ProxyTenantTimerApi->updateTimers: $@\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.ProxyTenantTimerApi()
tenantId = tenantId_example # String |  (default to null)
timerDescriptor =  # TimerDescriptor | 

try:
    api_instance.update_timers(tenantId, timerDescriptor)
except ApiException as e:
    print("Exception when calling ProxyTenantTimerApi->updateTimers: %s\n" % e)

extern crate ProxyTenantTimerApi;

pub fn main() {
    let tenantId = tenantId_example; // String
    let timerDescriptor = ; // TimerDescriptor

    let mut context = ProxyTenantTimerApi::Context::default();
    let result = client.updateTimers(tenantId, timerDescriptor, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
tenant_id*	String Required

Body parameters

Name	Description
timerDescriptor *

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

Version

getVersion

Get Okapi version

/_/version

Usage and SDK Samples

curl -X GET \
 "http://localhost:8081/_/version"

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

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

public class VersionApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        VersionApi apiInstance = new VersionApi();

        try {
            apiInstance.getVersion();
        } catch (ApiException e) {
            System.err.println("Exception when calling VersionApi#getVersion");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getVersion();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getVersion: $e\n');
}

import org.openapitools.client.api.VersionApi;

public class VersionApiExample {
    public static void main(String[] args) {
        VersionApi apiInstance = new VersionApi();

        try {
            apiInstance.getVersion();
        } catch (ApiException e) {
            System.err.println("Exception when calling VersionApi#getVersion");
            e.printStackTrace();
        }
    }
}



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

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

var OkapiCoreApiFacade = require('okapi_core_api_facade');

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

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

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

            // Create an instance of the API class
            var apiInstance = new VersionApi();

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

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

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

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

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

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

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

try:
    api_instance.get_version()
except ApiException as e:
    print("Exception when calling VersionApi->getVersion: %s\n" % e)

extern crate VersionApi;

pub fn main() {

    let mut context = VersionApi::Context::default();
    let result = client.getVersion(&context).wait();

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

Scopes

Parameters

Responses

Headers

Name	Type	Format	Description
X-Okapi-Trace	String

Okapi Core API Facade

API and SDK Documentation

Deployment

deleteDeployedModuleInstance

Usage and SDK Samples

Scopes

Parameters

Responses

deployModuleInstance

Usage and SDK Samples

Scopes

Parameters

Responses

getAllDeployedModuleInstances

Usage and SDK Samples

Scopes

Parameters

Responses

getDeployedModuleInstance

Usage and SDK Samples

Scopes

Parameters

Responses

Discovery

createDiscovery

Usage and SDK Samples

Scopes

Parameters

Responses

deleteAllDiscoveries

Usage and SDK Samples

Scopes

Parameters

Responses

deleteDiscoveriesByService

Usage and SDK Samples

Scopes

Parameters

Responses

deleteDiscoveryByInstance

Usage and SDK Samples

Scopes

Parameters

Responses

getAllDiscoveries

Usage and SDK Samples

Scopes

Parameters

Responses

getAllDiscoveryHealth

Usage and SDK Samples

Scopes

Parameters

Responses

getAllDiscoveryNodes

Usage and SDK Samples

Scopes

Parameters

Responses

getDiscoveriesByService

Usage and SDK Samples

Scopes

Parameters

Responses

getDiscoveryByInstance

Usage and SDK Samples

Scopes

Parameters

Responses

getDiscoveryHealthByInstance

Usage and SDK Samples

Scopes

Parameters

Responses

getDiscoveryHealthByService

Usage and SDK Samples

Scopes

Parameters

Responses

getDiscoveryNode