Rest APIs

Andy X is an open-source distributed streaming platform designed to deliver the best performance possible for high-performance data pipelines, streaming analytics, streaming between microservices and data integrations.

Authentication #

• HTTP Authentication, scheme: basic Basic Authorization header using the Bearer scheme.

Activities

get__api_v3_activities_tenants_count #

Code samples

## You can also use wget
curl -X GET /api/v3/activities/tenants/count \
  -H 'Accept: application/json'

GET /api/v3/activities/tenants/count HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/activities/tenants/count',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/activities/tenants/count',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/activities/tenants/count', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/activities/tenants/count', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/activities/tenants/count");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/activities/tenants/count", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/activities/tenants/count

Example responses

200 Response

0

Responses

get__api_v3_activities_products_count #

Code samples

## You can also use wget
curl -X GET /api/v3/activities/products/count \
  -H 'Accept: application/json'

GET /api/v3/activities/products/count HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/activities/products/count',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/activities/products/count',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/activities/products/count', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/activities/products/count', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/activities/products/count");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/activities/products/count", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/activities/products/count

Example responses

200 Response

0

Responses

get__api_v3_activities_components_count #

Code samples

## You can also use wget
curl -X GET /api/v3/activities/components/count \
  -H 'Accept: application/json'

GET /api/v3/activities/components/count HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/activities/components/count',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/activities/components/count',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/activities/components/count', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/activities/components/count', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/activities/components/count");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/activities/components/count", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/activities/components/count

Example responses

200 Response

0

Responses

get__api_v3_activities_topics_count #

Code samples

## You can also use wget
curl -X GET /api/v3/activities/topics/count \
  -H 'Accept: application/json'

GET /api/v3/activities/topics/count HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/activities/topics/count',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/activities/topics/count',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/activities/topics/count', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/activities/topics/count', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/activities/topics/count");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/activities/topics/count", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/activities/topics/count

Example responses

200 Response

0

Responses

get__api_v3_activities_subscriptions_count #

Code samples

## You can also use wget
curl -X GET /api/v3/activities/subscriptions/count \
  -H 'Accept: application/json'

GET /api/v3/activities/subscriptions/count HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/activities/subscriptions/count',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/activities/subscriptions/count',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/activities/subscriptions/count', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/activities/subscriptions/count', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/activities/subscriptions/count");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/activities/subscriptions/count", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/activities/subscriptions/count

Example responses

200 Response

0

Responses

get__api_v3_activities_producers_count #

Code samples

## You can also use wget
curl -X GET /api/v3/activities/producers/count \
  -H 'Accept: application/json'

GET /api/v3/activities/producers/count HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/activities/producers/count',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/activities/producers/count',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/activities/producers/count', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/activities/producers/count', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/activities/producers/count");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/activities/producers/count", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/activities/producers/count

Example responses

200 Response

0

Responses

get__api_v3_activities_subscriptions #

Code samples

## You can also use wget
curl -X GET /api/v3/activities/subscriptions \
  -H 'Accept: application/json'

GET /api/v3/activities/subscriptions HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/activities/subscriptions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/activities/subscriptions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/activities/subscriptions', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/activities/subscriptions', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/activities/subscriptions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/activities/subscriptions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/activities/subscriptions

Example responses

200 Response

[
  {
    "name": "string",
    "location": "string",
    "isActive": true
  }
]

Responses

Response Schema

Status Code 200

get__api_v3_activities_producers #

Code samples

## You can also use wget
curl -X GET /api/v3/activities/producers \
  -H 'Accept: application/json'

GET /api/v3/activities/producers HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/activities/producers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/activities/producers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/activities/producers', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/activities/producers', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/activities/producers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/activities/producers", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/activities/producers

Example responses

200 Response

[
  {
    "key": "string",
    "tenant": "string",
    "name": "string",
    "location": "string",
    "isActive": true,
    "instancesCount": 0
  }
]

Responses

Response Schema

Status Code 200

Clusters

get__api_v3_clusters #

Code samples

## You can also use wget
curl -X GET /api/v3/clusters \
  -H 'Accept: application/json'

GET /api/v3/clusters HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/clusters',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/clusters',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/clusters', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/clusters', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/clusters");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/clusters", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/clusters

Example responses

200 Response

{
  "inThroughputInMB": 0,
  "outThroughputInMB": 0,
  "activeDataIngestions": 0,
  "activeSubscriptions": 0,
  "name": "string",
  "shardDistributionType": "Sync",
  "status": "Online",
  "shards": [
    {
      "replicaDistributionType": "Sync",
      "replicas": [
        {
          "nodeId": "string",
          "host": "string",
          "port": "string",
          "connectionType": "SSL",
          "username": "string",
          "password": "string",
          "type": "Main",
          "isConnected": true,
          "isLocal": true,
          "x509CertificateFile": "string",
          "x509CertificatePassword": "string"
        }
      ]
    }
  ]
}

Responses

get__api_v3_clusters_nodes_current #

Code samples

## You can also use wget
curl -X GET /api/v3/clusters/nodes/current \
  -H 'Accept: application/json'

GET /api/v3/clusters/nodes/current HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/clusters/nodes/current',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/clusters/nodes/current',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/clusters/nodes/current', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/clusters/nodes/current', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/clusters/nodes/current");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/clusters/nodes/current", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/clusters/nodes/current

Example responses

200 Response

{
  "nodeId": "string",
  "host": "string",
  "port": "string",
  "connectionType": "SSL",
  "username": "string",
  "password": "string",
  "type": "Main",
  "isConnected": true,
  "isLocal": true,
  "x509CertificateFile": "string",
  "x509CertificatePassword": "string"
}

Responses

Components

get__api_v3_tenants_{tenant}products{product}_components #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components

Parameters

Example responses

200 Response

[
  "string"
]

Responses

Response Schema

get__api_v3_tenants_{tenant}products{product}components{component} #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components/{component} \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components/{component} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components/{component}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components/{component}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components/{component}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components/{component}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}

Parameters

Example responses

200 Response

{
  "id": 0,
  "name": "string",
  "description": "string",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Responses

post__api_v3_tenants_{tenant}products{product}components{component} #

Code samples

## You can also use wget
curl -X POST /api/v3/tenants/{tenant}/products/{product}/components/{component} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /api/v3/tenants/{tenant}/products/{product}/components/{component} HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "isTopicAutomaticCreationAllowed": true,
  "enforceSchemaValidation": true,
  "isAuthorizationEnabled": true,
  "isSubscriptionAutomaticCreationAllowed": true,
  "isProducerAutomaticCreationAllowed": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '/api/v3/tenants/{tenant}/products/{product}/components/{component}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('/api/v3/tenants/{tenant}/products/{product}/components/{component}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/api/v3/tenants/{tenant}/products/{product}/components/{component}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/v3/tenants/{tenant}/products/{product}/components/{component}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/v3/tenants/{tenant}/products/{product}/components/{component}

Body parameter

{
  "isTopicAutomaticCreationAllowed": true,
  "enforceSchemaValidation": true,
  "isAuthorizationEnabled": true,
  "isSubscriptionAutomaticCreationAllowed": true,
  "isProducerAutomaticCreationAllowed": true
}

Parameters

Example responses

200 Response

"string"

Responses

put__api_v3_tenants_{tenant}products{product}components{component} #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/products/{product}/components/{component} \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/products/{product}/components/{component} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/products/{product}/components/{component}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/products/{product}/components/{component}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/products/{product}/components/{component}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/products/{product}/components/{component}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}

Parameters

Example responses

200 Response

"string"

Responses

delete__api_v3_tenants_{tenant}products{product}components{component} #

Code samples

## You can also use wget
curl -X DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component} \
  -H 'Accept: application/json'

DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.delete '/api/v3/tenants/{tenant}/products/{product}/components/{component}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.delete('/api/v3/tenants/{tenant}/products/{product}/components/{component}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/api/v3/tenants/{tenant}/products/{product}/components/{component}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/v3/tenants/{tenant}/products/{product}/components/{component}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}

Parameters

Example responses

200 Response

"string"

Responses

get__api_v3_tenants_{tenant}products{product}components{component}_settings #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/settings \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/settings HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/settings',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components/{component}/settings',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components/{component}/settings', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components/{component}/settings', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/settings");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/settings", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/settings

Parameters

Example responses

200 Response

{
  "isTopicAutomaticCreationAllowed": true,
  "enforceSchemaValidation": true,
  "isAuthorizationEnabled": true,
  "isSubscriptionAutomaticCreationAllowed": true,
  "isProducerAutomaticCreationAllowed": true
}

Responses

put__api_v3_tenants_{tenant}products{product}components{component}_settings #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/settings \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/settings HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "isTopicAutomaticCreationAllowed": true,
  "enforceSchemaValidation": true,
  "isAuthorizationEnabled": true,
  "isSubscriptionAutomaticCreationAllowed": true,
  "isProducerAutomaticCreationAllowed": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/settings',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/products/{product}/components/{component}/settings',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/products/{product}/components/{component}/settings', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/products/{product}/components/{component}/settings', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/settings");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/settings", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/settings

Body parameter

{
  "isTopicAutomaticCreationAllowed": true,
  "enforceSchemaValidation": true,
  "isAuthorizationEnabled": true,
  "isSubscriptionAutomaticCreationAllowed": true,
  "isProducerAutomaticCreationAllowed": true
}

Parameters

Example responses

200 Response

"string"

Responses

post__api_v3_tenants_{tenant}products{product}components{component}_tokens #

Code samples

## You can also use wget
curl -X POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "roles": [
    "Produce"
  ],
  "isActive": true,
  "expireDate": "2019-08-24T14:15:22Z",
  "issuedFor": "string",
  "description": "string",
  "issuedDate": "2019-08-24T14:15:22Z",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens

Body parameter

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "roles": [
    "Produce"
  ],
  "isActive": true,
  "expireDate": "2019-08-24T14:15:22Z",
  "issuedFor": "string",
  "description": "string",
  "issuedDate": "2019-08-24T14:15:22Z",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Parameters

Example responses

200 Response

"string"

Responses

get__api_v3_tenants_{tenant}products{product}components{component}_tokens #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens

Parameters

Example responses

200 Response

[
  {
    "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
    "roles": [
      "Produce"
    ],
    "isActive": true,
    "expireDate": "2019-08-24T14:15:22Z",
    "issuedFor": "string",
    "description": "string",
    "issuedDate": "2019-08-24T14:15:22Z",
    "updatedDate": "2019-08-24T14:15:22Z",
    "createdDate": "2019-08-24T14:15:22Z",
    "updatedBy": "string",
    "createdBy": "string"
  }
]

Responses

Response Schema

Status Code 200

put__api_v3_tenants_{tenant}products{product}components{component}tokens{key}_revoke #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}/revoke \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}/revoke HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}/revoke',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}/revoke',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}/revoke', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}/revoke', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}/revoke");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}/revoke", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}/revoke

Parameters

Example responses

200 Response

"string"

Responses

get__api_v3_tenants_{tenant}products{product}components{component}tokens{key} #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key} \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/tokens/{key}

Parameters

Example responses

200 Response

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "roles": [
    "Produce"
  ],
  "isActive": true,
  "expireDate": "2019-08-24T14:15:22Z",
  "issuedFor": "string",
  "description": "string",
  "issuedDate": "2019-08-24T14:15:22Z",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Responses

get__api_v3_tenants_{tenant}products{product}components{component}_retentions #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions

Parameters

Example responses

200 Response

[
  {
    "id": 0,
    "name": "string",
    "type": "SOFT_TTL",
    "timeToLiveInMinutes": 0,
    "updatedDate": "2019-08-24T14:15:22Z",
    "createdDate": "2019-08-24T14:15:22Z",
    "updatedBy": "string",
    "createdBy": "string"
  }
]

Responses

Response Schema

Status Code 200

Enumerated Values #

post__api_v3_tenants_{tenant}products{product}components{component}_retentions #

Code samples

## You can also use wget
curl -X POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions

Body parameter

{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Parameters

Example responses

200 Response

"string"

Responses

put__api_v3_tenants_{tenant}products{product}components{component}retentions{id} #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id} HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}

Body parameter

{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Parameters

Example responses

200 Response

"string"

Responses

delete__api_v3_tenants_{tenant}products{product}components{component}retentions{id} #

Code samples

## You can also use wget
curl -X DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id} \
  -H 'Accept: application/json'

DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.delete '/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.delete('/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}/retentions/{id}

Parameters

Example responses

200 Response

"string"

Responses

Node

get__api_v3_node_version #

Code samples

## You can also use wget
curl -X GET /api/v3/node/version \
  -H 'Accept: text/plain'

GET /api/v3/node/version HTTP/1.1

Accept: text/plain

const headers = {
  'Accept':'text/plain'
};

fetch('/api/v3/node/version',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain'
}

result = RestClient.get '/api/v3/node/version',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'text/plain'
}

r = requests.get('/api/v3/node/version', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'text/plain',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/node/version', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/node/version");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/node/version", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/node/version

Example responses

200 Response

{"name":"string","shortName":"string","version":"string"}

{
  "name": "string",
  "shortName": "string",
  "version": "string"
}

Responses

get__api_v3_node_users_role #

Code samples

## You can also use wget
curl -X GET /api/v3/node/users/role \
  -H 'Accept: text/plain'

GET /api/v3/node/users/role HTTP/1.1

Accept: text/plain

const headers = {
  'Accept':'text/plain'
};

fetch('/api/v3/node/users/role',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain'
}

result = RestClient.get '/api/v3/node/users/role',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'text/plain'
}

r = requests.get('/api/v3/node/users/role', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'text/plain',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/node/users/role', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/node/users/role");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/node/users/role", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/node/users/role

Example responses

200 Response

"string"

"string"

Responses

Producers

get__api_v3_tenants_{tenant}products{product}components{component}topics{topic}_producers #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers

Parameters

Example responses

200 Response

[
  "string"
]

Responses

Response Schema

get__api_v3_tenants_{tenant}products{product}components{component}topics{topic}producers{producer} #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer} \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}

Parameters

Example responses

200 Response

{
  "id": 0,
  "name": "string",
  "description": "string",
  "instanceType": "Single",
  "publicIpRange": [
    "string"
  ],
  "privateIpRange": [
    "string"
  ],
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Responses

post__api_v3_tenants_{tenant}products{product}components{component}topics{topic}producers{producer} #

Code samples

## You can also use wget
curl -X POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer} \
  -H 'Accept: application/json'

POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.post '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.post('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}

Parameters

Enumerated Values #

Example responses

200 Response

{
  "tenant": "string",
  "product": "string",
  "component": "string",
  "topic": "string",
  "subscriptionName": "string",
  "subscriptionType": "Unique",
  "subscriptionMode": "Resilient",
  "initialPosition": "Earliest",
  "consumersConnected": {
    "property1": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    }
  },
  "consumerExternalConnected": {
    "property1": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    }
  },
  "currentConnectionIndex": 0,
  "subscriptionPositionContext": {
    "database": {
      "currentTransaction": {
        "transactionId": "75906707-8c31-479c-b354-aa805c4cefbc",
        "supportsSavepoints": true
      },
      "autoTransactionsEnabled": true,
      "autoSavepointsEnabled": true,
      "providerName": "string"
    },
    "changeTracker": {
      "autoDetectChangesEnabled": true,
      "lazyLoadingEnabled": true,
      "queryTrackingBehavior": "TrackAll",
      "deleteOrphansTiming": "Immediate",
      "cascadeDeleteTiming": "Immediate",
      "context": {},
      "debugView": {
        "longView": "string",
        "shortView": "string"
      }
    },
    "model": {
      "modelDependencies": {
        "typeMappingSource": {},
        "constructorBindingFactory": {},
        "parameterBindingFactories": {}
      }
    },
    "contextId": {
      "instanceId": "64d2028c-ae87-4069-a624-66089d957ef9",
      "lease": 0
    }
  },
  "createdDate": "2019-08-24T14:15:22Z"
}

Responses

delete__api_v3_tenants_{tenant}products{product}components{component}topics{topic}producers{producer} #

Code samples

## You can also use wget
curl -X DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer} \
  -H 'Accept: application/json'

DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.delete '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.delete('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/producers/{producer}

Parameters

Example responses

200 Response

{
  "tenant": "string",
  "product": "string",
  "component": "string",
  "topic": "string",
  "subscriptionName": "string",
  "subscriptionType": "Unique",
  "subscriptionMode": "Resilient",
  "initialPosition": "Earliest",
  "consumersConnected": {
    "property1": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    }
  },
  "consumerExternalConnected": {
    "property1": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    }
  },
  "currentConnectionIndex": 0,
  "subscriptionPositionContext": {
    "database": {
      "currentTransaction": {
        "transactionId": "75906707-8c31-479c-b354-aa805c4cefbc",
        "supportsSavepoints": true
      },
      "autoTransactionsEnabled": true,
      "autoSavepointsEnabled": true,
      "providerName": "string"
    },
    "changeTracker": {
      "autoDetectChangesEnabled": true,
      "lazyLoadingEnabled": true,
      "queryTrackingBehavior": "TrackAll",
      "deleteOrphansTiming": "Immediate",
      "cascadeDeleteTiming": "Immediate",
      "context": {},
      "debugView": {
        "longView": "string",
        "shortView": "string"
      }
    },
    "model": {
      "modelDependencies": {
        "typeMappingSource": {},
        "constructorBindingFactory": {},
        "parameterBindingFactories": {}
      }
    },
    "contextId": {
      "instanceId": "64d2028c-ae87-4069-a624-66089d957ef9",
      "lease": 0
    }
  },
  "createdDate": "2019-08-24T14:15:22Z"
}

Responses

Products

get__api_v3_tenants_{tenant}_products #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products

Parameters

Example responses

200 Response

[
  "string"
]

Responses

Response Schema

get__api_v3_tenants_{tenant}products{product} #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product} \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}

Parameters

Example responses

200 Response

{
  "id": 0,
  "name": "string",
  "description": "string",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Responses

post__api_v3_tenants_{tenant}products{product} #

Code samples

## You can also use wget
curl -X POST /api/v3/tenants/{tenant}/products/{product} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /api/v3/tenants/{tenant}/products/{product} HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "isAuthorizationEnabled": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '/api/v3/tenants/{tenant}/products/{product}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('/api/v3/tenants/{tenant}/products/{product}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/api/v3/tenants/{tenant}/products/{product}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/v3/tenants/{tenant}/products/{product}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/v3/tenants/{tenant}/products/{product}

Body parameter

{
  "isAuthorizationEnabled": true
}

Parameters

Example responses

200 Response

"string"

Responses

put__api_v3_tenants_{tenant}products{product} #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/products/{product} \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/products/{product} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/products/{product}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/products/{product}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/products/{product}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/products/{product}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/products/{product}

Parameters

Example responses

200 Response

{
  "id": 0,
  "name": "string",
  "description": "string",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Responses

delete__api_v3_tenants_{tenant}products{product}_delete #

Code samples

## You can also use wget
curl -X DELETE /api/v3/tenants/{tenant}/products/{product}/delete \
  -H 'Accept: application/json'

DELETE /api/v3/tenants/{tenant}/products/{product}/delete HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/delete',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.delete '/api/v3/tenants/{tenant}/products/{product}/delete',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.delete('/api/v3/tenants/{tenant}/products/{product}/delete', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/api/v3/tenants/{tenant}/products/{product}/delete', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/delete");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/v3/tenants/{tenant}/products/{product}/delete", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/v3/tenants/{tenant}/products/{product}/delete

Parameters

Example responses

200 Response

"string"

Responses

get__api_v3_tenants_{tenant}products{product}_settings #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/settings \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/settings HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/settings',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/settings',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/settings', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/settings', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/settings");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/settings", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/settings

Parameters

Example responses

200 Response

{
  "isAuthorizationEnabled": true
}

Responses

put__api_v3_tenants_{tenant}products{product}_settings #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/products/{product}/settings \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/products/{product}/settings HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "isAuthorizationEnabled": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/settings',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/products/{product}/settings',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/products/{product}/settings', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/products/{product}/settings', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/settings");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/products/{product}/settings", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/products/{product}/settings

Body parameter

{
  "isAuthorizationEnabled": true
}

Parameters

Example responses

200 Response

"string"

Responses

post__api_v3_tenants_{tenant}products{product}_tokens #

Code samples

## You can also use wget
curl -X POST /api/v3/tenants/{tenant}/products/{product}/tokens \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /api/v3/tenants/{tenant}/products/{product}/tokens HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "roles": [
    "Produce"
  ],
  "isActive": true,
  "expireDate": "2019-08-24T14:15:22Z",
  "description": "string",
  "issuedDate": "2019-08-24T14:15:22Z",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/tokens',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '/api/v3/tenants/{tenant}/products/{product}/tokens',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('/api/v3/tenants/{tenant}/products/{product}/tokens', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/api/v3/tenants/{tenant}/products/{product}/tokens', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/tokens");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/v3/tenants/{tenant}/products/{product}/tokens", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/v3/tenants/{tenant}/products/{product}/tokens

Body parameter

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "roles": [
    "Produce"
  ],
  "isActive": true,
  "expireDate": "2019-08-24T14:15:22Z",
  "description": "string",
  "issuedDate": "2019-08-24T14:15:22Z",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Parameters

Example responses

200 Response

"string"

Responses

get__api_v3_tenants_{tenant}products{product}_tokens #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/tokens \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/tokens HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/tokens',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/tokens',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/tokens', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/tokens', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/tokens");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/tokens", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/tokens

Parameters

Example responses

200 Response

[
  {
    "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
    "roles": [
      "Produce"
    ],
    "isActive": true,
    "expireDate": "2019-08-24T14:15:22Z",
    "description": "string",
    "issuedDate": "2019-08-24T14:15:22Z",
    "updatedDate": "2019-08-24T14:15:22Z",
    "createdDate": "2019-08-24T14:15:22Z",
    "updatedBy": "string",
    "createdBy": "string"
  }
]

Responses

Response Schema

Status Code 200

put__api_v3_tenants_{tenant}products{product}tokens{key}_revoke #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/products/{product}/tokens/{key}/revoke \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/products/{product}/tokens/{key}/revoke HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/tokens/{key}/revoke',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/products/{product}/tokens/{key}/revoke',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/products/{product}/tokens/{key}/revoke', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/products/{product}/tokens/{key}/revoke', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/tokens/{key}/revoke");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/products/{product}/tokens/{key}/revoke", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/products/{product}/tokens/{key}/revoke

Parameters

Example responses

200 Response

"string"

Responses

get__api_v3_tenants_{tenant}products{product}tokens{key} #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/tokens/{key} \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/tokens/{key} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/tokens/{key}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/tokens/{key}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/tokens/{key}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/tokens/{key}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/tokens/{key}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/tokens/{key}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/tokens/{key}

Parameters

Example responses

200 Response

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "roles": [
    "Produce"
  ],
  "isActive": true,
  "expireDate": "2019-08-24T14:15:22Z",
  "description": "string",
  "issuedDate": "2019-08-24T14:15:22Z",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Responses

get__api_v3_tenants_{tenant}products{product}_retentions #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/retentions \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/retentions HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/retentions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/retentions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/retentions', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/retentions', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/retentions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/retentions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/retentions

Parameters

Example responses

200 Response

[
  {
    "id": 0,
    "name": "string",
    "type": "SOFT_TTL",
    "timeToLiveInMinutes": 0,
    "updatedDate": "2019-08-24T14:15:22Z",
    "createdDate": "2019-08-24T14:15:22Z",
    "updatedBy": "string",
    "createdBy": "string"
  }
]

Responses

Response Schema

Status Code 200

Enumerated Values #

post__api_v3_tenants_{tenant}products{product}_retentions #

Code samples

## You can also use wget
curl -X POST /api/v3/tenants/{tenant}/products/{product}/retentions \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /api/v3/tenants/{tenant}/products/{product}/retentions HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/retentions',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '/api/v3/tenants/{tenant}/products/{product}/retentions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('/api/v3/tenants/{tenant}/products/{product}/retentions', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/api/v3/tenants/{tenant}/products/{product}/retentions', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/retentions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/v3/tenants/{tenant}/products/{product}/retentions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/v3/tenants/{tenant}/products/{product}/retentions

Body parameter

{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Parameters

Example responses

200 Response

"string"

Responses

put__api_v3_tenants_{tenant}products{product}retentions{id} #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/products/{product}/retentions/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/products/{product}/retentions/{id} HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/retentions/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/products/{product}/retentions/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/products/{product}/retentions/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/products/{product}/retentions/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/retentions/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/products/{product}/retentions/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/products/{product}/retentions/{id}

Body parameter

{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Parameters

Example responses

200 Response

"string"

Responses

delete__api_v3_tenants_{tenant}products{product}retentions{id} #

Code samples

## You can also use wget
curl -X DELETE /api/v3/tenants/{tenant}/products/{product}/retentions/{id} \
  -H 'Accept: application/json'

DELETE /api/v3/tenants/{tenant}/products/{product}/retentions/{id} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/retentions/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.delete '/api/v3/tenants/{tenant}/products/{product}/retentions/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.delete('/api/v3/tenants/{tenant}/products/{product}/retentions/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/api/v3/tenants/{tenant}/products/{product}/retentions/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/retentions/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/v3/tenants/{tenant}/products/{product}/retentions/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/v3/tenants/{tenant}/products/{product}/retentions/{id}

Parameters

Example responses

200 Response

"string"

Responses

Subscriptions

get__api_v3_tenants_{tenant}products{product}components{component}topics{topic}_subscriptions #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions

Parameters

Example responses

200 Response

[
  "string"
]

Responses

Response Schema

get__api_v3_tenants_{tenant}products{product}components{component}topics{topic}subscriptions{subscription} #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription} \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}

Parameters

Example responses

200 Response

{
  "tenant": "string",
  "product": "string",
  "component": "string",
  "topic": "string",
  "subscriptionName": "string",
  "subscriptionType": "Unique",
  "subscriptionMode": "Resilient",
  "initialPosition": "Earliest",
  "consumersConnected": {
    "property1": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    }
  },
  "consumerExternalConnected": {
    "property1": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    }
  },
  "currentConnectionIndex": 0,
  "subscriptionPositionContext": {
    "database": {
      "currentTransaction": {
        "transactionId": "75906707-8c31-479c-b354-aa805c4cefbc",
        "supportsSavepoints": true
      },
      "autoTransactionsEnabled": true,
      "autoSavepointsEnabled": true,
      "providerName": "string"
    },
    "changeTracker": {
      "autoDetectChangesEnabled": true,
      "lazyLoadingEnabled": true,
      "queryTrackingBehavior": "TrackAll",
      "deleteOrphansTiming": "Immediate",
      "cascadeDeleteTiming": "Immediate",
      "context": {},
      "debugView": {
        "longView": "string",
        "shortView": "string"
      }
    },
    "model": {
      "modelDependencies": {
        "typeMappingSource": {},
        "constructorBindingFactory": {},
        "parameterBindingFactories": {}
      }
    },
    "contextId": {
      "instanceId": "64d2028c-ae87-4069-a624-66089d957ef9",
      "lease": 0
    }
  },
  "createdDate": "2019-08-24T14:15:22Z"
}

Responses

post__api_v3_tenants_{tenant}products{product}components{component}topics{topic}subscriptions{subscription} #

Code samples

## You can also use wget
curl -X POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription} \
  -H 'Accept: application/json'

POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.post '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.post('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}

Parameters

Enumerated Values #

Example responses

200 Response

{
  "tenant": "string",
  "product": "string",
  "component": "string",
  "topic": "string",
  "subscriptionName": "string",
  "subscriptionType": "Unique",
  "subscriptionMode": "Resilient",
  "initialPosition": "Earliest",
  "consumersConnected": {
    "property1": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    }
  },
  "consumerExternalConnected": {
    "property1": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    }
  },
  "currentConnectionIndex": 0,
  "subscriptionPositionContext": {
    "database": {
      "currentTransaction": {
        "transactionId": "75906707-8c31-479c-b354-aa805c4cefbc",
        "supportsSavepoints": true
      },
      "autoTransactionsEnabled": true,
      "autoSavepointsEnabled": true,
      "providerName": "string"
    },
    "changeTracker": {
      "autoDetectChangesEnabled": true,
      "lazyLoadingEnabled": true,
      "queryTrackingBehavior": "TrackAll",
      "deleteOrphansTiming": "Immediate",
      "cascadeDeleteTiming": "Immediate",
      "context": {},
      "debugView": {
        "longView": "string",
        "shortView": "string"
      }
    },
    "model": {
      "modelDependencies": {
        "typeMappingSource": {},
        "constructorBindingFactory": {},
        "parameterBindingFactories": {}
      }
    },
    "contextId": {
      "instanceId": "64d2028c-ae87-4069-a624-66089d957ef9",
      "lease": 0
    }
  },
  "createdDate": "2019-08-24T14:15:22Z"
}

Responses

delete__api_v3_tenants_{tenant}products{product}components{component}topics{topic}subscriptions{subscription} #

Code samples

## You can also use wget
curl -X DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription} \
  -H 'Accept: application/json'

DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.delete '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.delete('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/subscriptions/{subscription}

Parameters

Example responses

200 Response

{
  "tenant": "string",
  "product": "string",
  "component": "string",
  "topic": "string",
  "subscriptionName": "string",
  "subscriptionType": "Unique",
  "subscriptionMode": "Resilient",
  "initialPosition": "Earliest",
  "consumersConnected": {
    "property1": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    }
  },
  "consumerExternalConnected": {
    "property1": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "subscription": "string",
      "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
      "name": "string",
      "connection": {
        "clientIpAddress": "string",
        "serverIpAddress": "string"
      },
      "connectedDate": "2019-08-24T14:15:22Z"
    }
  },
  "currentConnectionIndex": 0,
  "subscriptionPositionContext": {
    "database": {
      "currentTransaction": {
        "transactionId": "75906707-8c31-479c-b354-aa805c4cefbc",
        "supportsSavepoints": true
      },
      "autoTransactionsEnabled": true,
      "autoSavepointsEnabled": true,
      "providerName": "string"
    },
    "changeTracker": {
      "autoDetectChangesEnabled": true,
      "lazyLoadingEnabled": true,
      "queryTrackingBehavior": "TrackAll",
      "deleteOrphansTiming": "Immediate",
      "cascadeDeleteTiming": "Immediate",
      "context": {},
      "debugView": {
        "longView": "string",
        "shortView": "string"
      }
    },
    "model": {
      "modelDependencies": {
        "typeMappingSource": {},
        "constructorBindingFactory": {},
        "parameterBindingFactories": {}
      }
    },
    "contextId": {
      "instanceId": "64d2028c-ae87-4069-a624-66089d957ef9",
      "lease": 0
    }
  },
  "createdDate": "2019-08-24T14:15:22Z"
}

Responses

Tenants

get__api_v3_tenants #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants \
  -H 'Accept: application/json'

GET /api/v3/tenants HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants

Example responses

200 Response

[
  "string"
]

Responses

Response Schema

get__api_v3_tenants_{tenant} #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant} \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}

Parameters

Example responses

200 Response

{
  "id": 0,
  "name": "string",
  "isActive": true,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Responses

post__api_v3_tenants_{tenant} #

Code samples

## You can also use wget
curl -X POST /api/v3/tenants/{tenant} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /api/v3/tenants/{tenant} HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "isProductAutomaticCreationAllowed": true,
  "isEncryptionEnabled": true,
  "isAuthorizationEnabled": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '/api/v3/tenants/{tenant}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('/api/v3/tenants/{tenant}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/api/v3/tenants/{tenant}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/v3/tenants/{tenant}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/v3/tenants/{tenant}

Body parameter

{
  "isProductAutomaticCreationAllowed": true,
  "isEncryptionEnabled": true,
  "isAuthorizationEnabled": true
}

Parameters

Example responses

200 Response

"string"

Responses

put__api_v3_tenants_{tenant}_activate #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/activate \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/activate HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/activate',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/activate',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/activate', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/activate', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/activate");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/activate", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/activate

Parameters

Example responses

200 Response

{
  "id": 0,
  "name": "string",
  "isActive": true,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Responses

put__api_v3_tenants_{tenant}_deactivate #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/deactivate \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/deactivate HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/deactivate',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/deactivate',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/deactivate', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/deactivate', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/deactivate");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/deactivate", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/deactivate

Parameters

Example responses

200 Response

{
  "id": 0,
  "name": "string",
  "isActive": true,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Responses

delete__api_v3_tenants_{tenant}_delete #

Code samples

## You can also use wget
curl -X DELETE /api/v3/tenants/{tenant}/delete \
  -H 'Accept: application/json'

DELETE /api/v3/tenants/{tenant}/delete HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/delete',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.delete '/api/v3/tenants/{tenant}/delete',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.delete('/api/v3/tenants/{tenant}/delete', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/api/v3/tenants/{tenant}/delete', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/delete");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/v3/tenants/{tenant}/delete", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/v3/tenants/{tenant}/delete

Parameters

Example responses

200 Response

"string"

Responses

get__api_v3_tenants_{tenant}_settings #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/settings \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/settings HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/settings',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/settings',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/settings', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/settings', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/settings");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/settings", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/settings

Parameters

Example responses

200 Response

{
  "isProductAutomaticCreationAllowed": true,
  "isEncryptionEnabled": true,
  "isAuthorizationEnabled": true
}

Responses

put__api_v3_tenants_{tenant}_settings #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/settings \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/settings HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "isProductAutomaticCreationAllowed": true,
  "isEncryptionEnabled": true,
  "isAuthorizationEnabled": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/settings',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/settings',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/settings', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/settings', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/settings");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/settings", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/settings

Body parameter

{
  "isProductAutomaticCreationAllowed": true,
  "isEncryptionEnabled": true,
  "isAuthorizationEnabled": true
}

Parameters

Example responses

200 Response

"string"

Responses

get__api_v3_tenants_{tenant}_tokens #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/tokens \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/tokens HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/tokens',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/tokens',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/tokens', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/tokens', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/tokens");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/tokens", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/tokens

Parameters

Example responses

200 Response

[
  "string"
]

Responses

Response Schema

post__api_v3_tenants_{tenant}_tokens #

Code samples

## You can also use wget
curl -X POST /api/v3/tenants/{tenant}/tokens \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /api/v3/tenants/{tenant}/tokens HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "isActive": true,
  "roles": [
    "Produce"
  ],
  "expireDate": "2019-08-24T14:15:22Z",
  "description": "string",
  "issuedDate": "2019-08-24T14:15:22Z",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/tokens',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '/api/v3/tenants/{tenant}/tokens',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('/api/v3/tenants/{tenant}/tokens', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/api/v3/tenants/{tenant}/tokens', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/tokens");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/v3/tenants/{tenant}/tokens", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/v3/tenants/{tenant}/tokens

Body parameter

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "isActive": true,
  "roles": [
    "Produce"
  ],
  "expireDate": "2019-08-24T14:15:22Z",
  "description": "string",
  "issuedDate": "2019-08-24T14:15:22Z",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Parameters

Example responses

200 Response

"string"

Responses

get__api_v3_tenants_{tenant}tokens{key} #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/tokens/{key} \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/tokens/{key} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/tokens/{key}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/tokens/{key}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/tokens/{key}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/tokens/{key}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/tokens/{key}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/tokens/{key}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/tokens/{key}

Parameters

Example responses

200 Response

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "isActive": true,
  "roles": [
    "Produce"
  ],
  "expireDate": "2019-08-24T14:15:22Z",
  "description": "string",
  "issuedDate": "2019-08-24T14:15:22Z",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Responses

put__api_v3_tenants_{tenant}tokens{key}_revoke #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/tokens/{key}/revoke \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/tokens/{key}/revoke HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/tokens/{key}/revoke',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/tokens/{key}/revoke',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/tokens/{key}/revoke', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/tokens/{key}/revoke', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/tokens/{key}/revoke");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/tokens/{key}/revoke", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/tokens/{key}/revoke

Parameters

Example responses

200 Response

"string"

Responses

get__api_v3_tenants_{tenant}_retentions #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/retentions \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/retentions HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/retentions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/retentions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/retentions', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/retentions', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/retentions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/retentions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/retentions

Parameters

Example responses

200 Response

[
  {
    "id": 0,
    "name": "string",
    "type": "SOFT_TTL",
    "timeToLiveInMinutes": 0,
    "updatedDate": "2019-08-24T14:15:22Z",
    "createdDate": "2019-08-24T14:15:22Z",
    "updatedBy": "string",
    "createdBy": "string"
  }
]

Responses

Response Schema

Status Code 200

Enumerated Values #

post__api_v3_tenants_{tenant}_retentions #

Code samples

## You can also use wget
curl -X POST /api/v3/tenants/{tenant}/retentions \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /api/v3/tenants/{tenant}/retentions HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/retentions',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '/api/v3/tenants/{tenant}/retentions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('/api/v3/tenants/{tenant}/retentions', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/api/v3/tenants/{tenant}/retentions', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/retentions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/v3/tenants/{tenant}/retentions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/v3/tenants/{tenant}/retentions

Body parameter

{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Parameters

Example responses

200 Response

"string"

Responses

put__api_v3_tenants_{tenant}retentions{id} #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/retentions/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/retentions/{id} HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/retentions/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/retentions/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/retentions/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/retentions/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/retentions/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/retentions/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/retentions/{id}

Body parameter

{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Parameters

Example responses

200 Response

"string"

Responses

delete__api_v3_tenants_{tenant}retentions{id} #

Code samples

## You can also use wget
curl -X DELETE /api/v3/tenants/{tenant}/retentions/{id} \
  -H 'Accept: application/json'

DELETE /api/v3/tenants/{tenant}/retentions/{id} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/retentions/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.delete '/api/v3/tenants/{tenant}/retentions/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.delete('/api/v3/tenants/{tenant}/retentions/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/api/v3/tenants/{tenant}/retentions/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/retentions/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/v3/tenants/{tenant}/retentions/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/v3/tenants/{tenant}/retentions/{id}

Parameters

Example responses

200 Response

"string"

Responses

Topics

get__api_v3_tenants_{tenant}products{product}components{component}_topics #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics

Parameters

Example responses

200 Response

[
  "string"
]

Responses

Response Schema

get__api_v3_tenants_{tenant}products{product}components{component}topics{topic} #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic} \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}

Parameters

Example responses

200 Response

{
  "id": 0,
  "name": "string",
  "description": "string",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Responses

post__api_v3_tenants_{tenant}products{product}components{component}topics{topic} #

Code samples

## You can also use wget
curl -X POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic} HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "writeBufferSizeInBytes": 0,
  "maxWriteBufferNumber": 0,
  "maxWriteBufferSizeToMaintain": 0,
  "minWriteBufferNumberToMerge": 0,
  "maxBackgroundCompactionsThreads": 0,
  "maxBackgroundFlushesThreads": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}

Body parameter

{
  "writeBufferSizeInBytes": 0,
  "maxWriteBufferNumber": 0,
  "maxWriteBufferSizeToMaintain": 0,
  "minWriteBufferNumberToMerge": 0,
  "maxBackgroundCompactionsThreads": 0,
  "maxBackgroundFlushesThreads": 0
}

Parameters

Example responses

200 Response

"string"

Responses

put__api_v3_tenants_{tenant}products{product}components{component}topics{topic} #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic} \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}

Parameters

Example responses

200 Response

"string"

Responses

delete__api_v3_tenants_{tenant}products{product}components{component}topics{topic} #

Code samples

## You can also use wget
curl -X DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic} \
  -H 'Accept: application/json'

DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic} HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.delete '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.delete('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}

Parameters

Example responses

200 Response

"string"

Responses

get__api_v3_tenants_{tenant}products{product}components{component}topics{topic}_settings #

Code samples

## You can also use wget
curl -X GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings \
  -H 'Accept: application/json'

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings HTTP/1.1

Accept: application/json

const headers = {
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings

Parameters

Example responses

200 Response

{
  "writeBufferSizeInBytes": 0,
  "maxWriteBufferNumber": 0,
  "maxWriteBufferSizeToMaintain": 0,
  "minWriteBufferNumberToMerge": 0,
  "maxBackgroundCompactionsThreads": 0,
  "maxBackgroundFlushesThreads": 0
}

Responses

put__api_v3_tenants_{tenant}products{product}components{component}topics{topic}_settings #

Code samples

## You can also use wget
curl -X PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings HTTP/1.1

Content-Type: application/json
Accept: application/json

const inputBody = '{
  "writeBufferSizeInBytes": 0,
  "maxWriteBufferNumber": 0,
  "maxWriteBufferSizeToMaintain": 0,
  "minWriteBufferNumberToMerge": 0,
  "maxBackgroundCompactionsThreads": 0,
  "maxBackgroundFlushesThreads": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.put '/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/v3/tenants/{tenant}/products/{product}/components/{component}/topics/{topic}/settings

Body parameter

{
  "writeBufferSizeInBytes": 0,
  "maxWriteBufferNumber": 0,
  "maxWriteBufferSizeToMaintain": 0,
  "minWriteBufferNumberToMerge": 0,
  "maxBackgroundCompactionsThreads": 0,
  "maxBackgroundFlushesThreads": 0
}

Parameters

Example responses

200 Response

"string"

Responses

Schemas #

ApplicationDetails

{
  "name": "string",
  "shortName": "string",
  "version": "string"
}

Properties #

CascadeTiming

"Immediate"

Properties #

Enumerated Values #

ChangeTracker

{
  "autoDetectChangesEnabled": true,
  "lazyLoadingEnabled": true,
  "queryTrackingBehavior": "TrackAll",
  "deleteOrphansTiming": "Immediate",
  "cascadeDeleteTiming": "Immediate",
  "context": {
    "database": {
      "currentTransaction": {
        "transactionId": "75906707-8c31-479c-b354-aa805c4cefbc",
        "supportsSavepoints": true
      },
      "autoTransactionsEnabled": true,
      "autoSavepointsEnabled": true,
      "providerName": "string"
    },
    "changeTracker": {
      "autoDetectChangesEnabled": true,
      "lazyLoadingEnabled": true,
      "queryTrackingBehavior": "TrackAll",
      "deleteOrphansTiming": "Immediate",
      "cascadeDeleteTiming": "Immediate",
      "context": {},
      "debugView": {
        "longView": "string",
        "shortView": "string"
      }
    },
    "model": {
      "modelDependencies": {
        "typeMappingSource": {},
        "constructorBindingFactory": {},
        "parameterBindingFactories": {}
      }
    },
    "contextId": {
      "instanceId": "64d2028c-ae87-4069-a624-66089d957ef9",
      "lease": 0
    }
  },
  "debugView": {
    "longView": "string",
    "shortView": "string"
  }
}

Properties #

Cluster

{
  "inThroughputInMB": 0,
  "outThroughputInMB": 0,
  "activeDataIngestions": 0,
  "activeSubscriptions": 0,
  "name": "string",
  "shardDistributionType": "Sync",
  "status": "Online",
  "shards": [
    {
      "replicaDistributionType": "Sync",
      "replicas": [
        {
          "nodeId": "string",
          "host": "string",
          "port": "string",
          "connectionType": "SSL",
          "username": "string",
          "password": "string",
          "type": "Main",
          "isConnected": true,
          "isLocal": true,
          "x509CertificateFile": "string",
          "x509CertificatePassword": "string"
        }
      ]
    }
  ]
}

Properties #

ClusterStatus

"Online"

Properties #

Enumerated Values #

Component

{
  "id": 0,
  "name": "string",
  "description": "string",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Properties #

ComponentRetention

{
  "id": 0,
  "name": "string",
  "type": "SOFT_TTL",
  "timeToLiveInMinutes": 0,
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Properties #

ComponentSettings

{
  "isTopicAutomaticCreationAllowed": true,
  "enforceSchemaValidation": true,
  "isAuthorizationEnabled": true,
  "isSubscriptionAutomaticCreationAllowed": true,
  "isProducerAutomaticCreationAllowed": true
}

Properties #

ComponentToken

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "roles": [
    "Produce"
  ],
  "isActive": true,
  "expireDate": "2019-08-24T14:15:22Z",
  "issuedFor": "string",
  "description": "string",
  "issuedDate": "2019-08-24T14:15:22Z",
  "updatedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "updatedBy": "string",
  "createdBy": "string"
}

Properties #

ComponentTokenRole

"Produce"

Properties #

Enumerated Values #

Consumer

{
  "subscription": "string",
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "name": "string",
  "connection": {
    "clientIpAddress": "string",
    "serverIpAddress": "string"
  },
  "connectedDate": "2019-08-24T14:15:22Z"
}

Properties #

ConsumerConnection

{
  "clientIpAddress": "string",
  "serverIpAddress": "string"
}

Properties #

DatabaseFacade

{
  "currentTransaction": {
    "transactionId": "75906707-8c31-479c-b354-aa805c4cefbc",
    "supportsSavepoints": true
  },
  "autoTransactionsEnabled": true,
  "autoSavepointsEnabled": true,
  "providerName": "string"
}

Properties #

DbContext

{
  "database": {
    "currentTransaction": {
      "transactionId": "75906707-8c31-479c-b354-aa805c4cefbc",
      "supportsSavepoints": true
    },
    "autoTransactionsEnabled": true,
    "autoSavepointsEnabled": true,
    "providerName": "string"
  },
  "changeTracker": {
    "autoDetectChangesEnabled": true,
    "lazyLoadingEnabled": true,
    "queryTrackingBehavior": "TrackAll",
    "deleteOrphansTiming": "Immediate",
    "cascadeDeleteTiming": "Immediate",
    "context": {
      "database": {
        "currentTransaction": {
          "transactionId": "75906707-8c31-479c-b354-aa805c4cefbc",
          "supportsSavepoints": true
        },
        "autoTransactionsEnabled": true,
        "autoSavepointsEnabled": true,
        "providerName": "string"
      },
      "changeTracker": {},
      "model": {
        "modelDependencies": {
          "typeMappingSource": {},
          "constructorBindingFactory": {},
          "parameterBindingFactories": {}
        }
      },
      "contextId": {
        "instanceId": "64d2028c-ae87-4069-a624-66089d957ef9",
        "lease": 0
      }
    },
    "debugView": {
      "longView": "string",
      "shortView": "string"
    }
  },
  "model": {
    "modelDependencies": {
      "typeMappingSource": {},
      "constructorBindingFactory": {},
      "parameterBindingFactories": {}
    }
  },
  "contextId": {
    "instanceId": "64d2028c-ae87-4069-a624-66089d957ef9",
    "lease": 0
  }
}

Properties #

DbContextId

{
  "instanceId": "64d2028c-ae87-4069-a624-66089d957ef9",
  "lease": 0
}

Properties #

DebugView

{
  "longView": "string",
  "shortView": "string"
}

Properties #

DistributionTypes

"Sync"

Properties #