Get Started

API Documentation

All
Api Keys
Authorization
Catalogs
Claims
Config
Machines
Orchestrator
Packer Templates
ReverseProxy
Roles
Users

API Documentation

This document describes the REST API for the service.

Creates an api key:

/api/v1/auth/api_keys Authorized
Role: SUPER_USER Claim: CREATE_API_KEY Claim: LIST

This endpoint creates an api key

This endpoint will create an api key in the system

API Keys are used to authenticate with the system from external applications

How are they different from a user?

A user normally has a password and is used to authenticate with the system An api key is used to authenticate with the system from an external application

Headers
x-filter Filter entities optional header
Parameters
apiKey Body body 
{
  "created_at": "string",
  "key": "string",
  "name": "string",
  "revoked": "bool",
  "revoked_at": "string",
  "secret": "string",
  "updated_at": "string"
}
Request examples
/v1/auth/api_keys Authorized 
curl --location 'http://localhost/api/v1/auth/api_keys' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "key": "Some Key",
  "secret": "SomeLongSecret"
  }
'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/auth/api_keys");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "created_at": "string",
  "key": "string",
  "name": "string",
  "revoked": "bool",
  "revoked_at": "string",
  "secret": "string",
  "updated_at": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/api_keys"
  method := "post"
  payload := strings.NewReader(`{
  "created_at": "string",
  "key": "string",
  "name": "string",
  "revoked": "bool",
  "revoked_at": "string",
  "secret": "string",
  "updated_at": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "encoded": "string",
  "id": "string",
  "key": "string",
  "name": "string",
  "revoked": "bool"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the api keys:

/api/v1/auth/api_keys Authorized
Claim: LIST_API_KEY

This endpoint returns all the api keys

Request examples
/v1/auth/api_keys Authorized 
curl --location 'http://localhost/api/v1/auth/api_keys' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/auth/api_keys");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/api_keys"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "encoded": "string",
  "id": "string",
  "key": "string",
  "name": "string",
  "revoked": "bool"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes an api key:

/api/v1/auth/api_keys/{id} Authorized
Claim: DELETE_API_KEY

This endpoint deletes an api key

Parameters
id Api Key ID required path
Request examples
/v1/auth/api_keys/{id} Authorized 
curl --location 'http://localhost/api/v1/auth/api_keys/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/auth/api_keys/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/api_keys/{id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets an api key by id or name:

/api/v1/auth/api_keys/{id} Authorized
Claim: LIST_API_KEY

This endpoint returns an api key by id or name

Parameters
id Api Key ID required path
Request examples
/v1/auth/api_keys/{id} Authorized 
curl --location 'http://localhost/api/v1/auth/api_keys/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/auth/api_keys/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/api_keys/{id}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "encoded": "string",
  "id": "string",
  "key": "string",
  "name": "string",
  "revoked": "bool"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Revoke an api key:

/api/v1/auth/api_keys/{id}/revoke Authorized
Role: SUPER_USER Claim: LIST_API_KEY Claim: DELETE_API_KEY

This endpoint revokes an api key

Parameters
id Api Key ID required path
Request examples
/v1/auth/api_keys/{id}/revoke Authorized 
curl --location 'http://localhost/api/v1/auth/api_keys/{id}/revoke' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/auth/api_keys/{id}/revoke");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/api_keys/{id}/revoke"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Generates a token:

/api/v1/auth/token Authorized

This endpoint generates a token

Parameters
login Body body 
{
  "email": "string",
  "password": "string"
}
Request examples
/v1/auth/token Authorized 
curl --location 'http://localhost/api/v1/auth/token' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "email": "string",
  "password": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/auth/token");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "email": "string",
  "password": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/token"
  method := "post"
  payload := strings.NewReader(`{
  "email": "string",
  "password": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "email": "string",
  "expires_at": "int64",
  "token": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Validates a token:

/api/v1/auth/token/validate Authorized

This endpoint validates a token

Parameters
tokenRequest Body body 
{
  "token": "string"
}
Request examples
/v1/auth/token/validate Authorized 
curl --location 'http://localhost/api/v1/auth/token/validate' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "token": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/auth/token/validate");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "token": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/token/validate"
  method := "post"
  payload := strings.NewReader(`{
  "token": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "valid": "bool"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the remote catalogs:

/api/v1/catalog Authorized

This endpoint returns all the remote catalogs

Request examples
/v1/catalog Authorized 
curl --location 'http://localhost/api/v1/catalog' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/catalog");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the remote catalogs:

/api/v1/catalog/{catalogId} Authorized

This endpoint returns all the remote catalogs

Parameters
catalogId Catalog ID required path
Request examples
/v1/catalog/{catalogId} Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/catalog/{catalogId}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets a catalog manifest version:

/api/v1/catalog/{catalogId}/{version} Authorized

This endpoint returns a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path
Request examples
/v1/catalog/{catalogId}/{version} Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/catalog/{catalogId}/{version}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets a catalog manifest version architecture:

/api/v1/catalog/{catalogId}/{version}/{architecture} Authorized

This endpoint returns a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path architecture Architecture required path
Request examples
/v1/catalog/{catalogId}/{version}/{architecture} Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Downloads a catalog manifest version:

/api/v1/catalog/{catalogId}/{version}/{architecture}/download Authorized

This endpoint downloads a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path architecture Architecture required path
Request examples
/v1/catalog/{catalogId}/{version}/{architecture}/download Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/download' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/download");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/download"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Taints a catalog manifest version:

/api/v1/catalog/{catalogId}/{version}/{architecture}/taint Authorized

This endpoint Taints a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path architecture Architecture required path
Request examples
/v1/catalog/{catalogId}/{version}/{architecture}/taint Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/taint' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Patch, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/taint");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/taint"
  method := "patch"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
UnTaints a catalog manifest version:

/api/v1/catalog/{catalogId}/{version}/{architecture}/untaint Authorized

This endpoint UnTaints a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path architecture Architecture required path
Request examples
/v1/catalog/{catalogId}/{version}/{architecture}/untaint Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/untaint' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Patch, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/untaint");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/untaint"
  method := "patch"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
UnTaints a catalog manifest version:

/api/v1/catalog/{catalogId}/{version}/{architecture}/revoke Authorized

This endpoint UnTaints a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path architecture Architecture required path
Request examples
/v1/catalog/{catalogId}/{version}/{architecture}/revoke Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/revoke' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Patch, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/revoke");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/revoke"
  method := "patch"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Adds claims to a catalog manifest version:

/api/v1/catalog/{catalogId}/{version}/{architecture}/claims Authorized

This endpoint adds claims to a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path architecture Architecture required path
request Body body 
{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}
Request examples
/v1/catalog/{catalogId}/{version}/{architecture}/claims Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/claims' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Patch, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/claims");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/claims"
  method := "patch"
  payload := strings.NewReader(`{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Removes claims from a catalog manifest version:

/api/v1/catalog/{catalogId}/{version}/{architecture}/claims Authorized

This endpoint removes claims from a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path architecture Architecture required path
request Body body 
{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}
Request examples
/v1/catalog/{catalogId}/{version}/{architecture}/claims Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/claims' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/claims");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/claims"
  method := "delete"
  payload := strings.NewReader(`{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Adds roles to a catalog manifest version:

/api/v1/catalog/{catalogId}/{version}/{architecture}/roles Authorized

This endpoint adds roles to a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path architecture Architecture required path
request Body body 
{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}
Request examples
/v1/catalog/{catalogId}/{version}/{architecture}/roles Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/roles' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Patch, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/roles");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/roles"
  method := "patch"
  payload := strings.NewReader(`{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Removes roles from a catalog manifest version:

/api/v1/catalog/{catalogId}/{version}/{architecture}/roles Authorized

This endpoint removes roles from a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path architecture Architecture required path
request Body body 
{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}
Request examples
/v1/catalog/{catalogId}/{version}/{architecture}/roles Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/roles' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/roles");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/roles"
  method := "delete"
  payload := strings.NewReader(`{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Adds tags to a catalog manifest version:

/api/v1/catalog/{catalogId}/{version}/{architecture}/tags Authorized

This endpoint adds tags to a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path architecture Architecture required path
request Body body 
{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}
Request examples
/v1/catalog/{catalogId}/{version}/{architecture}/tags Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/tags' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Patch, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/tags");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/tags"
  method := "patch"
  payload := strings.NewReader(`{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Removes tags from a catalog manifest version:

/api/v1/catalog/{catalogId}/{version}/{architecture}/tags Authorized

This endpoint removes tags from a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path architecture Architecture required path
request Body body 
{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}
Request examples
/v1/catalog/{catalogId}/{version}/{architecture}/tags Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/tags' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/tags");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/tags"
  method := "delete"
  payload := strings.NewReader(`{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes a catalog manifest and all its versions:

/api/v1/catalog/{catalogId} Authorized

This endpoint deletes a catalog manifest and all its versions

Parameters
catalogId Catalog ID required path
Request examples
/v1/catalog/{catalogId} Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/catalog/{catalogId}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes a catalog manifest version:

/api/v1/catalog/{catalogId}/{version} Authorized

This endpoint deletes a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path
Request examples
/v1/catalog/{catalogId}/{version} Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/catalog/{catalogId}/{version}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes a catalog manifest version architecture:

/api/v1/catalog/{catalogId}/{version}/{architecture} Authorized

This endpoint deletes a catalog manifest version

Parameters
catalogId Catalog ID required path version Version required path architecture Architecture required path
Request examples
/v1/catalog/{catalogId}/{version}/{architecture} Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Pushes a catalog manifest to the catalog inventory:

/api/v1/catalog/push Authorized

This endpoint pushes a catalog manifest to the catalog inventory

Parameters
pushRequest Push request body 
{
  "architecture": "string",
  "catalog_id": "string",
  "compress_pack": "bool",
  "connection": "string",
  "description": "string",
  "local_path": "string",
  "minimum_requirements": {
    "cpu": "int",
    "disk": "int",
    "memory": "int"
  },
  "pack_size": "int64",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string",
  "uuid": "string",
  "version": "string"
}
Request examples
/v1/catalog/push Authorized 
curl --location 'http://localhost/api/v1/catalog/push' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "architecture": "string",
  "catalog_id": "string",
  "compress_pack": "bool",
  "connection": "string",
  "description": "string",
  "local_path": "string",
  "minimum_requirements": {
    "cpu": "int",
    "disk": "int",
    "memory": "int"
  },
  "pack_size": "int64",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string",
  "uuid": "string",
  "version": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/catalog/push");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "architecture": "string",
  "catalog_id": "string",
  "compress_pack": "bool",
  "connection": "string",
  "description": "string",
  "local_path": "string",
  "minimum_requirements": {
    "cpu": "int",
    "disk": "int",
    "memory": "int"
  },
  "pack_size": "int64",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string",
  "uuid": "string",
  "version": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/push"
  method := "post"
  payload := strings.NewReader(`{
  "architecture": "string",
  "catalog_id": "string",
  "compress_pack": "bool",
  "connection": "string",
  "description": "string",
  "local_path": "string",
  "minimum_requirements": {
    "cpu": "int",
    "disk": "int",
    "memory": "int"
  },
  "pack_size": "int64",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string",
  "uuid": "string",
  "version": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Pull a remote catalog manifest:

/api/v1/catalog/pull Authorized

This endpoint pulls a remote catalog manifest

Parameters
pullRequest Pull request body 
{
  "architecture": "string",
  "catalog_id": "string",
  "client": "string",
  "connection": "string",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "provider_metadata": "map[string]string",
  "start_after_pull": "bool",
  "version": "string"
}
Request examples
/v1/catalog/pull Authorized 
curl --location 'http://localhost/api/v1/catalog/pull' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "architecture": "string",
  "catalog_id": "string",
  "client": "string",
  "connection": "string",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "provider_metadata": "map[string]string",
  "start_after_pull": "bool",
  "version": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/catalog/pull");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "architecture": "string",
  "catalog_id": "string",
  "client": "string",
  "connection": "string",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "provider_metadata": "map[string]string",
  "start_after_pull": "bool",
  "version": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/pull"
  method := "put"
  payload := strings.NewReader(`{
  "architecture": "string",
  "catalog_id": "string",
  "client": "string",
  "connection": "string",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "provider_metadata": "map[string]string",
  "start_after_pull": "bool",
  "version": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "architecture": "string",
  "catalog_id": "string",
  "id": "string",
  "local_cache_path": "string",
  "local_path": "string",
  "machine_id": "string",
  "machine_name": "string",
  "manifest": "*VirtualMachineCatalogManifest",
  "version": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Imports a remote catalog manifest metadata into the catalog inventory:

/api/v1/catalog/import Authorized

This endpoint imports a remote catalog manifest metadata into the catalog inventory

Parameters
importRequest Pull request body 
{
  "architecture": "string",
  "catalog_id": "string",
  "connection": "string",
  "provider_metadata": "map[string]string",
  "version": "string"
}
Request examples
/v1/catalog/import Authorized 
curl --location 'http://localhost/api/v1/catalog/import' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "architecture": "string",
  "catalog_id": "string",
  "connection": "string",
  "provider_metadata": "map[string]string",
  "version": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/catalog/import");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "architecture": "string",
  "catalog_id": "string",
  "connection": "string",
  "provider_metadata": "map[string]string",
  "version": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/import"
  method := "put"
  payload := strings.NewReader(`{
  "architecture": "string",
  "catalog_id": "string",
  "connection": "string",
  "provider_metadata": "map[string]string",
  "version": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "id": "string",
  "local_path": "string",
  "machine_name": "string",
  "manifest": "*VirtualMachineCatalogManifest"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Imports a vm into the catalog inventory generating the metadata for it:

/api/v1/catalog/import-vm Authorized

This endpoint imports a virtual machine in pvm or macvm format into the catalog inventory generating the metadata for it

Parameters
importRequest Vm Impoty request body 
{
  "architecture": "string",
  "catalog_id": "string",
  "connection": "string",
  "description": "string",
  "force": "bool",
  "is_compressed": "bool",
  "machine_remote_path": "string",
  "provider_metadata": "map[string]string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "size": "int64",
  "tags": "[]string",
  "type": "string",
  "version": "string"
}
Request examples
/v1/catalog/import-vm Authorized 
curl --location 'http://localhost/api/v1/catalog/import-vm' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "architecture": "string",
  "catalog_id": "string",
  "connection": "string",
  "description": "string",
  "force": "bool",
  "is_compressed": "bool",
  "machine_remote_path": "string",
  "provider_metadata": "map[string]string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "size": "int64",
  "tags": "[]string",
  "type": "string",
  "version": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/catalog/import-vm");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "architecture": "string",
  "catalog_id": "string",
  "connection": "string",
  "description": "string",
  "force": "bool",
  "is_compressed": "bool",
  "machine_remote_path": "string",
  "provider_metadata": "map[string]string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "size": "int64",
  "tags": "[]string",
  "type": "string",
  "version": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/import-vm"
  method := "put"
  payload := strings.NewReader(`{
  "architecture": "string",
  "catalog_id": "string",
  "connection": "string",
  "description": "string",
  "force": "bool",
  "is_compressed": "bool",
  "machine_remote_path": "string",
  "provider_metadata": "map[string]string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "size": "int64",
  "tags": "[]string",
  "type": "string",
  "version": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "id": "string",
  "local_path": "string",
  "machine_name": "string",
  "manifest": "*VirtualMachineCatalogManifest"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Updates a catalog:

/api/v1/catalog/{catalogId}/{version}/{architecture}/claims Authorized

This endpoint adds claims to a catalog manifest version

Parameters
catalogId Catalog ID required path
request Body body 
{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}
Request examples
/v1/catalog/{catalogId}/{version}/{architecture}/claims Authorized 
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/claims' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Patch, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/claims");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/claims"
  method := "patch"
  payload := strings.NewReader(`{
  "connection": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "tags": "[]string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets catalog cache:

/api/v1/catalog/cache Authorized

This endpoint returns all the remote catalog cache if any

Request examples
/v1/catalog/cache Authorized 
curl --location 'http://localhost/api/v1/catalog/cache' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/catalog/cache");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/cache"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "catalog_id": "string",
    "created_at": "string",
    "description": "string",
    "download_count": "int",
    "id": "string",
    "is_compressed": "bool",
    "last_downloaded_at": "string",
    "last_downloaded_user": "string",
    "metadata_path": "string",
    "minimum_requirements": "*MinimumSpecRequirement",
    "name": "string",
    "pack_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ],
    "pack_path": "string",
    "pack_relative_path": "string",
    "pack_size": "int64",
    "path": "string",
    "provider": "*CatalogManifestProvider",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "revoked": "bool",
    "revoked_at": "string",
    "revoked_by": "string",
    "size": "int64",
    "tags": "[]string",
    "tainted": "bool",
    "tainted_at": "string",
    "tainted_by": "string",
    "type": "string",
    "untainted_by": "string",
    "updated_at": "string",
    "version": "string",
    "virtual_machine_contents": [
      {
        "created_at": "string",
        "deleted_at": "string",
        "hash": "string",
        "is_dir": "bool",
        "name": "string",
        "path": "string",
        "size": "int64",
        "updated_at": "string"
      }
    ]
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes all catalog cache:

/api/v1/catalog/cache Authorized

This endpoint returns all the remote catalog cache if any

Parameters
catalogId Catalog ID required path
Request examples
/v1/catalog/cache Authorized 
curl --location 'http://localhost/api/v1/catalog/cache' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/catalog/cache");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/cache"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes catalog cache item and all its versions:

/api/v1/catalog/cache/{catalogId} Authorized

This endpoint returns all the remote catalog cache if any and all its versions

Parameters
catalogId Catalog ID required path
Request examples
/v1/catalog/cache/{catalogId} Authorized 
curl --location 'http://localhost/api/v1/catalog/cache/{catalogId}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/catalog/cache/{catalogId}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/cache/{catalogId}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes catalog cache version item:

/api/v1/catalog/cache/{catalogId}/{version} Authorized

This endpoint deletes a version of a cache ite,

Parameters
catalogId Catalog ID required path version Version required path
Request examples
/v1/catalog/cache/{catalogId}/{version} Authorized 
curl --location 'http://localhost/api/v1/catalog/cache/{catalogId}/{version}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/catalog/cache/{catalogId}/{version}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/catalog/cache/{catalogId}/{version}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the claims:

/api/v1/auth/claims Authorized

This endpoint returns all the claims

Request examples
/v1/auth/claims Authorized 
curl --location 'http://localhost/api/v1/auth/claims' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/auth/claims");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/claims"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "id": "string",
    "name": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets a claim:

/api/v1/auth/claims/{id} Authorized

This endpoint returns a claim

Parameters
id Claim ID required path
Request examples
/v1/auth/claims/{id} Authorized 
curl --location 'http://localhost/api/v1/auth/claims/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/auth/claims/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/claims/{id}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "id": "string",
    "name": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates a claim:

/api/v1/auth/claims Authorized

This endpoint creates a claim

Parameters
claimRequest Claim Request body 
{
  "name": "string"
}
Request examples
/v1/auth/claims Authorized 
curl --location 'http://localhost/api/v1/auth/claims' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "name": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/auth/claims");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "name": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/claims"
  method := "post"
  payload := strings.NewReader(`{
  "name": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "id": "string",
    "name": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Delete a claim:

/api/v1/auth/claims/{id} Authorized

This endpoint Deletes a claim

Parameters
id Claim ID required path
Request examples
/v1/auth/claims/{id} Authorized 
curl --location 'http://localhost/api/v1/auth/claims/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/auth/claims/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/claims/{id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets Parallels Desktop active license:

/api/v1/parallels_desktop/key Authorized

This endpoint returns Parallels Desktop active license

Request examples
/v1/parallels_desktop/key Authorized 
curl --location 'http://localhost/api/v1/parallels_desktop/key' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/parallels_desktop/key");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/parallels_desktop/key"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "advanced_restrictions": "string",
  "cpu_total": "int64",
  "deferred_activation": "string",
  "edition": "string",
  "expiration": "string",
  "grace_period_ends_at": "string",
  "is_volume": "string",
  "main_period_ends_at": "string",
  "max_memory": "int64",
  "serial": "string",
  "status": "string",
  "uuid": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Installs API requires 3rd party tools:

/api/v1/config/tools/install Authorized

This endpoint installs API requires 3rd party tools

Parameters
installToolsRequest Install Tools Request body 
{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]InstallToolsRequestItem"
}
Request examples
/v1/config/tools/install Authorized 
curl --location 'http://localhost/api/v1/config/tools/install' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]InstallToolsRequestItem"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/config/tools/install");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]InstallToolsRequestItem"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/config/tools/install"
  method := "post"
  payload := strings.NewReader(`{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]InstallToolsRequestItem"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "installed_tools": "map[string]InstallToolsResponseItem",
  "success": "bool"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Uninstalls API requires 3rd party tools:

/api/v1/config/tools/uninstall Authorized

This endpoint uninstalls API requires 3rd party tools

Parameters
uninstallToolsRequest Uninstall Tools Request body 
{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]UninstallToolsRequestItem",
  "uninstall_dependencies": "bool"
}
Request examples
/v1/config/tools/uninstall Authorized 
curl --location 'http://localhost/api/v1/config/tools/uninstall' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]UninstallToolsRequestItem",
  "uninstall_dependencies": "bool"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/config/tools/uninstall");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]UninstallToolsRequestItem",
  "uninstall_dependencies": "bool"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/config/tools/uninstall"
  method := "post"
  payload := strings.NewReader(`{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]UninstallToolsRequestItem",
  "uninstall_dependencies": "bool"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "installed_tools": "map[string]InstallToolsResponseItem",
  "success": "bool"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Restarts the API Service:

/api/v1/config/tools/restart Authorized

This endpoint restarts the API Service

Request examples
/v1/config/tools/restart Authorized 
curl --location 'http://localhost/api/v1/config/tools/restart' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/config/tools/restart");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/config/tools/restart"
  method := "post"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets the Hardware Info:

/api/v1/config/hardware Authorized

This endpoint returns the Hardware Info

Request examples
/v1/config/hardware Authorized 
curl --location 'http://localhost/api/v1/config/hardware' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/config/hardware");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/config/hardware"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "cpu_brand": "string",
  "cpu_type": "string",
  "devops_version": "string",
  "external_ip_address": "string",
  "is_log_streaming_enabled": "bool",
  "is_reverse_proxy_enabled": "bool",
  "os_name": "string",
  "os_version": "string",
  "parallels_desktop_licensed": "bool",
  "parallels_desktop_version": "string",
  "reverse_proxy": "*SystemReverseProxy",
  "system_reserved": "*SystemUsageItem",
  "total": "*SystemUsageItem",
  "total_available": "*SystemUsageItem",
  "total_in_use": "*SystemUsageItem",
  "total_reserved": "*SystemUsageItem"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets the API System Health:

/api/health/system Authorized

This endpoint returns the API Health Probe

Parameters
full query
Request examples
/health/system Authorized 
curl --location 'http://localhost/api/health/system' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/health/system");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/health/system"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Gets the system logs from the disk:

/api/logs Authorized

This endpoint returns the system logs from the disk

Request examples
/logs Authorized 
curl --location 'http://localhost/api/logs' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/logs");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/logs"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Streams the system logs via WebSocket:

/api/logs/stream Authorized

This endpoint streams the system logs in real-time via WebSocket

Request examples
/logs/stream Authorized 
curl --location 'http://localhost/api/logs/stream' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/logs/stream");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/logs/stream"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the virtual machines:

/api/v1/machines Authorized

This endpoint returns all the virtual machines

Parameters
filter header
Request examples
/v1/machines Authorized 
curl --location 'http://localhost/api/v1/machines' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets a virtual machine:

/api/v1/machines/{id} Authorized

This endpoint returns a virtual machine

Parameters
id Machine ID required path
Request examples
/v1/machines/{id} Authorized 
curl --location 'http://localhost/api/v1/machines/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Starts a virtual machine:

/api/v1/machines/{id}/start Authorized

This endpoint starts a virtual machine

Parameters
id Machine ID required path
Request examples
/v1/machines/{id}/start Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/start' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}/start");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/start"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "id": "string",
  "operation": "string",
  "status": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Stops a virtual machine:

/api/v1/machines/{id}/stop Authorized

This endpoint stops a virtual machine

Parameters
id Machine ID required path
Request examples
/v1/machines/{id}/stop Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/stop' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}/stop");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/stop"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "id": "string",
  "operation": "string",
  "status": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Restarts a virtual machine:

/api/v1/machines/{id}/restart Authorized

This endpoint restarts a virtual machine

Parameters
id Machine ID required path
Request examples
/v1/machines/{id}/restart Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/restart' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}/restart");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/restart"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "id": "string",
  "operation": "string",
  "status": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Suspends a virtual machine:

/api/v1/machines/{id}/suspend Authorized

This endpoint suspends a virtual machine

Parameters
id Machine ID required path
Request examples
/v1/machines/{id}/suspend Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/suspend' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}/suspend");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/suspend"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "id": "string",
  "operation": "string",
  "status": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Resumes a virtual machine:

/api/v1/machines/{id}/resume Authorized

This endpoint resumes a virtual machine

Parameters
id Machine ID required path
Request examples
/v1/machines/{id}/resume Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/resume' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}/resume");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/resume"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "id": "string",
  "operation": "string",
  "status": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Reset a virtual machine:

/api/v1/machines/{id}/reset Authorized

This endpoint reset a virtual machine

Parameters
id Machine ID required path
Request examples
/v1/machines/{id}/reset Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/reset' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}/reset");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/reset"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "id": "string",
  "operation": "string",
  "status": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Pauses a virtual machine:

/api/v1/machines/{id}/pause Authorized

This endpoint pauses a virtual machine

Parameters
id Machine ID required path
Request examples
/v1/machines/{id}/pause Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/pause' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}/pause");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/pause"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "id": "string",
  "operation": "string",
  "status": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes a virtual machine:

/api/v1/machines/{id} Authorized

This endpoint deletes a virtual machine

Parameters
id Machine ID required path
Request examples
/v1/machines/{id} Authorized 
curl --location 'http://localhost/api/v1/machines/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/machines/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get the current state of a virtual machine:

/api/v1/machines/{id}/status Authorized

This endpoint returns the current state of a virtual machine

Parameters
id Machine ID required path
Request examples
/v1/machines/{id}/status Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/status' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}/status");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/status"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "id": "string",
  "ip_configured": "string",
  "status": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Configures a virtual machine:

/api/v1/machines/{id}/set Authorized

This endpoint configures a virtual machine

Parameters
id Machine ID required path
configRequest Machine Set Request body 
{
  "operations": "[]*VirtualMachineConfigRequestOperation",
  "owner": "string"
}
Request examples
/v1/machines/{id}/set Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/set' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "operations": "[]*VirtualMachineConfigRequestOperation",
  "owner": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/machines/{id}/set");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "operations": "[]*VirtualMachineConfigRequestOperation",
  "owner": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/set"
  method := "put"
  payload := strings.NewReader(`{
  "operations": "[]*VirtualMachineConfigRequestOperation",
  "owner": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Clones a virtual machine:

/api/v1/machines/{id}/clone Authorized

This endpoint clones a virtual machine

Parameters
id Machine ID required path
configRequest Machine Clone Request body 
{
  "clone_name": "string"
}
Request examples
/v1/machines/{id}/clone Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/clone' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "clone_name": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/machines/{id}/clone");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "clone_name": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/clone"
  method := "put"
  payload := strings.NewReader(`{
  "clone_name": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "error": "string",
  "id": "string",
  "status": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Executes a command on a virtual machine:

/api/v1/machines/{id}/execute Authorized

This endpoint executes a command on a virtual machine

Parameters
id Machine ID required path
executeRequest Machine Execute Command Request body 
{
  "command": "string",
  "environment_variables": "map[string]string",
  "script": "*VirtualMachineExecuteCommandScript",
  "use_ssh": "bool",
  "use_sudo": "bool",
  "user": "string"
}
Request examples
/v1/machines/{id}/execute Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/execute' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "command": "string",
  "environment_variables": "map[string]string",
  "script": "*VirtualMachineExecuteCommandScript",
  "use_ssh": "bool",
  "use_sudo": "bool",
  "user": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/machines/{id}/execute");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "command": "string",
  "environment_variables": "map[string]string",
  "script": "*VirtualMachineExecuteCommandScript",
  "use_ssh": "bool",
  "use_sudo": "bool",
  "user": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/execute"
  method := "put"
  payload := strings.NewReader(`{
  "command": "string",
  "environment_variables": "map[string]string",
  "script": "*VirtualMachineExecuteCommandScript",
  "use_ssh": "bool",
  "use_sudo": "bool",
  "user": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "error": "string",
  "exit_code": "int",
  "stderr": "string",
  "stdout": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Uploads a file to a virtual machine:

/api/v1/machines/{id}/upload Authorized

This endpoint executes a command on a virtual machine

Parameters
id Machine ID required path
executeRequest Machine Upload file Command Request body 
{
  "path": "string",
  "remote_path": "string"
}
Request examples
/v1/machines/{id}/upload Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/upload' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "path": "string",
  "remote_path": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/machines/{id}/upload");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "path": "string",
  "remote_path": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/upload"
  method := "post"
  payload := strings.NewReader(`{
  "path": "string",
  "remote_path": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "error": "string",
  "path": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Renames a virtual machine:

/api/v1/machines/{id}/rename Authorized

This endpoint Renames a virtual machine

Parameters
id Machine ID required path
renameRequest Machine Rename Request body 
{
  "current_name": "string",
  "description": "string",
  "id": "string",
  "new_name": "string"
}
Request examples
/v1/machines/{id}/rename Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/rename' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "current_name": "string",
  "description": "string",
  "id": "string",
  "new_name": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/machines/{id}/rename");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "current_name": "string",
  "description": "string",
  "id": "string",
  "new_name": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/rename"
  method := "put"
  payload := strings.NewReader(`{
  "current_name": "string",
  "description": "string",
  "id": "string",
  "new_name": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Registers a virtual machine:

/api/v1/machines/register Authorized

This endpoint registers a virtual machine

Parameters
id Machine ID required path
registerRequest Machine Register Request body 
{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}
Request examples
/v1/machines/register Authorized 
curl --location 'http://localhost/api/v1/machines/register' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/machines/register");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/register"
  method := "post"
  payload := strings.NewReader(`{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Unregister a virtual machine:

/api/v1/machines/{id}/unregister Authorized

This endpoint unregister a virtual machine

Parameters
id Machine ID required path
unregisterRequest Machine Unregister Request body 
{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}
Request examples
/v1/machines/{id}/unregister Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/unregister' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/machines/{id}/unregister");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines/{id}/unregister"
  method := "post"
  payload := strings.NewReader(`{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "data": "unknown",
  "error": "unknown",
  "operation": "string",
  "success": "bool"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates a virtual machine:

/api/v1/machines Authorized

This endpoint creates a virtual machine

Parameters
createRequest New Machine Request body 
{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}
Request examples
/v1/machines Authorized 
curl --location 'http://localhost/api/v1/machines' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/machines");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/machines"
  method := "post"
  payload := strings.NewReader(`{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "current_state": "string",
  "host": "string",
  "id": "string",
  "name": "string",
  "owner": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all hosts from the orchestrator:

/api/v1/orchestrator/hosts Authorized

This endpoint returns all hosts from the orchestrator

Request examples
/v1/orchestrator/hosts Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "cpu_model": "string",
    "description": "string",
    "detailed_resources": "*HostResources",
    "devops_version": "string",
    "enabled": "bool",
    "external_ip_address": "string",
    "host": "string",
    "id": "string",
    "is_reverse_proxy_enabled": "bool",
    "os_name": "string",
    "os_version": "string",
    "parallels_desktop_licensed": "bool",
    "parallels_desktop_version": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "resources": {
      "disk_size": "float64",
      "free_disk_size": "float64",
      "logical_cpu_count": "int64",
      "memory_size": "float64",
      "physical_cpu_count": "int64",
      "total_apple_vms": "int64"
    },
    "reverse_proxy": "*HostReverseProxy",
    "reverse_proxy_hosts": "[]*ReverseProxyHost",
    "state": "string",
    "tags": "[]string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets a host from the orchestrator:

/api/v1/orchestrator/hosts/{id} Authorized

This endpoint returns a host from the orchestrator

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "cpu_model": "string",
    "description": "string",
    "detailed_resources": "*HostResources",
    "devops_version": "string",
    "enabled": "bool",
    "external_ip_address": "string",
    "host": "string",
    "id": "string",
    "is_reverse_proxy_enabled": "bool",
    "os_name": "string",
    "os_version": "string",
    "parallels_desktop_licensed": "bool",
    "parallels_desktop_version": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "resources": {
      "disk_size": "float64",
      "free_disk_size": "float64",
      "logical_cpu_count": "int64",
      "memory_size": "float64",
      "physical_cpu_count": "int64",
      "total_apple_vms": "int64"
    },
    "reverse_proxy": "*HostReverseProxy",
    "reverse_proxy_hosts": "[]*ReverseProxyHost",
    "state": "string",
    "tags": "[]string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets a host hardware info from the orchestrator:

/api/v1/orchestrator/hosts/{id}/hardware Authorized

This endpoint returns a host hardware info from the orchestrator

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/hardware Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/hardware' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/hardware");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/hardware"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "cpu_brand": "string",
  "cpu_type": "string",
  "devops_version": "string",
  "external_ip_address": "string",
  "is_log_streaming_enabled": "bool",
  "is_reverse_proxy_enabled": "bool",
  "os_name": "string",
  "os_version": "string",
  "parallels_desktop_licensed": "bool",
  "parallels_desktop_version": "string",
  "reverse_proxy": "*SystemReverseProxy",
  "system_reserved": "*SystemUsageItem",
  "total": "*SystemUsageItem",
  "total_available": "*SystemUsageItem",
  "total_in_use": "*SystemUsageItem",
  "total_reserved": "*SystemUsageItem"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Register a Host in the orchestrator:

/api/v1/orchestrator/hosts Authorized

This endpoint register a host in the orchestrator

Parameters
hostRequest Host Request body 
{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "schema": "string",
  "tags": "[]string"
}
Request examples
/v1/orchestrator/hosts Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "schema": "string",
  "tags": "[]string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "schema": "string",
  "tags": "[]string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts"
  method := "post"
  payload := strings.NewReader(`{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "schema": "string",
  "tags": "[]string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "cpu_model": "string",
    "description": "string",
    "detailed_resources": "*HostResources",
    "devops_version": "string",
    "enabled": "bool",
    "external_ip_address": "string",
    "host": "string",
    "id": "string",
    "is_reverse_proxy_enabled": "bool",
    "os_name": "string",
    "os_version": "string",
    "parallels_desktop_licensed": "bool",
    "parallels_desktop_version": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "resources": {
      "disk_size": "float64",
      "free_disk_size": "float64",
      "logical_cpu_count": "int64",
      "memory_size": "float64",
      "physical_cpu_count": "int64",
      "total_apple_vms": "int64"
    },
    "reverse_proxy": "*HostReverseProxy",
    "reverse_proxy_hosts": "[]*ReverseProxyHost",
    "state": "string",
    "tags": "[]string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Unregister a host from the orchestrator:

/api/v1/orchestrator/hosts/{id} Authorized

This endpoint unregister a host from the orchestrator

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Enable a host in the orchestrator:

/api/v1/orchestrator/hosts/{id}/enable Authorized

This endpoint will enable an existing host in the orchestrator

Request examples
/v1/orchestrator/hosts/{id}/enable Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/enable' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/enable");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/enable"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "cpu_model": "string",
    "description": "string",
    "detailed_resources": "*HostResources",
    "devops_version": "string",
    "enabled": "bool",
    "external_ip_address": "string",
    "host": "string",
    "id": "string",
    "is_reverse_proxy_enabled": "bool",
    "os_name": "string",
    "os_version": "string",
    "parallels_desktop_licensed": "bool",
    "parallels_desktop_version": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "resources": {
      "disk_size": "float64",
      "free_disk_size": "float64",
      "logical_cpu_count": "int64",
      "memory_size": "float64",
      "physical_cpu_count": "int64",
      "total_apple_vms": "int64"
    },
    "reverse_proxy": "*HostReverseProxy",
    "reverse_proxy_hosts": "[]*ReverseProxyHost",
    "state": "string",
    "tags": "[]string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Disable a host in the orchestrator:

/api/v1/orchestrator/hosts/{id}/disable Authorized

This endpoint will disable an existing host in the orchestrator

Request examples
/v1/orchestrator/hosts/{id}/disable Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/disable' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/disable");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/disable"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "cpu_model": "string",
    "description": "string",
    "detailed_resources": "*HostResources",
    "devops_version": "string",
    "enabled": "bool",
    "external_ip_address": "string",
    "host": "string",
    "id": "string",
    "is_reverse_proxy_enabled": "bool",
    "os_name": "string",
    "os_version": "string",
    "parallels_desktop_licensed": "bool",
    "parallels_desktop_version": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "resources": {
      "disk_size": "float64",
      "free_disk_size": "float64",
      "logical_cpu_count": "int64",
      "memory_size": "float64",
      "physical_cpu_count": "int64",
      "total_apple_vms": "int64"
    },
    "reverse_proxy": "*HostReverseProxy",
    "reverse_proxy_hosts": "[]*ReverseProxyHost",
    "state": "string",
    "tags": "[]string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Update a Host in the orchestrator:

/api/v1/orchestrator/hosts Authorized

This endpoint updates a host in the orchestrator

Parameters
hostRequest Host Update Request body 
{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "schema": "string"
}
Request examples
/v1/orchestrator/hosts Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "schema": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "schema": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts"
  method := "put"
  payload := strings.NewReader(`{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "schema": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "architecture": "string",
    "cpu_model": "string",
    "description": "string",
    "detailed_resources": "*HostResources",
    "devops_version": "string",
    "enabled": "bool",
    "external_ip_address": "string",
    "host": "string",
    "id": "string",
    "is_reverse_proxy_enabled": "bool",
    "os_name": "string",
    "os_version": "string",
    "parallels_desktop_licensed": "bool",
    "parallels_desktop_version": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "resources": {
      "disk_size": "float64",
      "free_disk_size": "float64",
      "logical_cpu_count": "int64",
      "memory_size": "float64",
      "physical_cpu_count": "int64",
      "total_apple_vms": "int64"
    },
    "reverse_proxy": "*HostReverseProxy",
    "reverse_proxy_hosts": "[]*ReverseProxyHost",
    "state": "string",
    "tags": "[]string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator resource overview:

/api/v1/orchestrator/overview/resources Authorized

This endpoint returns orchestrator resource overview

Request examples
/v1/orchestrator/overview/resources Authorized 
curl --location 'http://localhost/api/v1/orchestrator/overview/resources' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/overview/resources");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/overview/resources"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "cpu_brand": "string",
  "cpu_type": "string",
  "system_reserved": "HostResourceItem",
  "total": "HostResourceItem",
  "total_available": "HostResourceItem",
  "total_in_use": "HostResourceItem",
  "total_reserved": "HostResourceItem"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator host resources:

/api/v1/orchestrator/overview/{id}/resources Authorized

This endpoint returns orchestrator host resources

Parameters
id Host ID required path
Request examples
/v1/orchestrator/overview/{id}/resources Authorized 
curl --location 'http://localhost/api/v1/orchestrator/overview/{id}/resources' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/overview/{id}/resources");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/overview/{id}/resources"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "cpu_brand": "string",
  "cpu_type": "string",
  "system_reserved": "HostResourceItem",
  "total": "HostResourceItem",
  "total_available": "HostResourceItem",
  "total_in_use": "HostResourceItem",
  "total_reserved": "HostResourceItem"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator Virtual Machines:

/api/v1/orchestrator/machines Authorized

This endpoint returns orchestrator Virtual Machines

Request examples
/v1/orchestrator/machines Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/machines");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/machines"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator Virtual Machine:

/api/v1/orchestrator/machines/{id} Authorized

This endpoint returns orchestrator Virtual Machine by its ID

Request examples
/v1/orchestrator/machines/{id} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/machines/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes orchestrator virtual machine:

/api/v1/orchestrator/machines/{id} Authorized

This endpoint deletes orchestrator virtual machine

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{id} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/machines/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator virtual machine status:

/api/v1/orchestrator/machines/{vmId}/status Authorized

This endpoint returns orchestrator virtual machine status

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{vmId}/status Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{vmId}/status' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/machines/{vmId}/status");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{vmId}/status"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Renames orchestrator virtual machine:

/api/v1/orchestrator/machines/{id}/rename Authorized

This endpoint renames orchestrator virtual machine

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{id}/rename Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/rename' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/rename");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/rename"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Configures orchestrator virtual machine:

/api/v1/orchestrator/machines/{vmId}/set Authorized

This endpoint configures orchestrator virtual machine

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{vmId}/set Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{vmId}/set' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{vmId}/set");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{vmId}/set"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Starts orchestrator virtual machine:

/api/v1/orchestrator/machines/{vmId}/start Authorized

This endpoint starts orchestrator virtual machine

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{vmId}/start Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{vmId}/start' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{vmId}/start");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{vmId}/start"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Stops orchestrator virtual machine:

/api/v1/orchestrator/machines/{vmId}/stop Authorized

This endpoint sops orchestrator virtual machine

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{vmId}/stop Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{vmId}/stop' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{vmId}/stop");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{vmId}/stop"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Executes a command in a orchestrator virtual machine:

/api/v1/orchestrator/machines/{vmId}/execute Authorized

This endpoint executes a command in a orchestrator virtual machine

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{vmId}/execute Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{vmId}/execute' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{vmId}/execute");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{vmId}/execute"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator host virtual machines:

/api/v1/orchestrator/hosts/{id}/machines Authorized

This endpoint returns orchestrator host virtual machines

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/machines Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/machines");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId} Authorized

This endpoint returns orchestrator host virtual machine

Parameters
id Host ID required path vmId Virtual Machine ID required path
Request examples
/v1/orchestrator/hosts/{id}/machines/{vmId} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId} Authorized

This endpoint deletes orchestrator host virtual machine

Parameters
id Host ID required path vmId Virtual Machine ID required path
Request examples
/v1/orchestrator/hosts/{id}/machines/{vmId} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator host virtual machine status:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/status Authorized

This endpoint returns orchestrator host virtual machine status

Parameters
id Host ID required path vmId Virtual Machine ID required path
Request examples
/v1/orchestrator/hosts/{id}/machines/{vmId}/status Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/status' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/status");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/status"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Renames orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/rename Authorized

This endpoint renames orchestrator host virtual machine

Parameters
id Host ID required path vmId Virtual Machine ID required path
Request examples
/v1/orchestrator/hosts/{id}/machines/{vmId}/rename Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/rename' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/rename");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/rename"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Configures orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/set Authorized

This endpoint configures orchestrator host virtual machine

Parameters
id Host ID required path vmId Virtual Machine ID required path
Request examples
/v1/orchestrator/hosts/{id}/machines/{vmId}/set Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/set' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/set");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/set"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Starts orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/start Authorized

This endpoint starts orchestrator host virtual machine

Parameters
id Host ID required path vmId Virtual Machine ID required path
Request examples
/v1/orchestrator/hosts/{id}/machines/{vmId}/start Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/start' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/start");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/start"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Starts orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/stop Authorized

This endpoint starts orchestrator host virtual machine

Parameters
id Host ID required path vmId Virtual Machine ID required path
Request examples
/v1/orchestrator/hosts/{id}/machines/{vmId}/stop Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/stop' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/stop");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/stop"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Executes a command in a orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/execute Authorized

This endpoint executes a command in a orchestrator host virtual machine

Parameters
id Host ID required path vmId Virtual Machine ID required path
Request examples
/v1/orchestrator/hosts/{id}/machines/{vmId}/execute Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/execute' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/execute");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/execute"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Register a virtual machine in a orchestrator host:

/api/v1/orchestrator/hosts/{id}/machines/register Authorized

This endpoint registers a virtual machine in a orchestrator host

Parameters
id Host ID required path
request Register Virtual Machine Request body 
{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}
Request examples
/v1/orchestrator/hosts/{id}/machines/register Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/register' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/register");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/register"
  method := "post"
  payload := strings.NewReader(`{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Unregister a virtual machine in a orchestrator host:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister Authorized

This endpoint unregister a virtual machine in a orchestrator host

Parameters
id Host ID required path vmId Virtual Machine ID required path
request Register Virtual Machine Request body 
{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}
Request examples
/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister"
  method := "post"
  payload := strings.NewReader(`{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "Advanced": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates a orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines Authorized

This endpoint creates a orchestrator host virtual machine

Parameters
id Host ID required path
request Create Virtual Machine Request body 
{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}
Request examples
/v1/orchestrator/hosts/{id}/machines Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/machines");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines"
  method := "post"
  payload := strings.NewReader(`{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "current_state": "string",
  "host": "string",
  "id": "string",
  "name": "string",
  "owner": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates a virtual machine in one of the hosts for the orchestrator:

/api/v1/orchestrator/machines Authorized

This endpoint creates a virtual machine in one of the hosts for the orchestrator

Parameters
request Create Virtual Machine Request body 
{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}
Request examples
/v1/orchestrator/machines Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/machines");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/machines"
  method := "post"
  payload := strings.NewReader(`{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "current_state": "string",
  "host": "string",
  "id": "string",
  "name": "string",
  "owner": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets orchestrator host reverse proxy configuration:

/api/v1/orchestrator/hosts/{id}/reverse-proxy Authorized

This endpoint returns orchestrator host reverse proxy configuration

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "enabled": "bool",
  "host": "string",
  "port": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets orchestrator host reverse proxy hosts:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts Authorized

This endpoint returns orchestrator host reverse proxy hosts

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets orchestrator host reverse proxy hosts:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized

This endpoint returns orchestrator host reverse proxy hosts

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates a orchestrator host reverse proxy host:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts Authorized

This endpoint creates a orchestrator host reverse proxy host

Parameters
request Create Host Reverse Proxy Host Request body 
{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts"
  method := "post"
  payload := strings.NewReader(`{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Updates an orchestrator host reverse proxy host:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized

This endpoint updates an orchestrator host reverse proxy host

Parameters
request Update Host Reverse Proxy Host Request body 
{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}"
  method := "put"
  payload := strings.NewReader(`{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes an orchestrator host reverse proxy host:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized

This endpoint deletes an orchestrator host reverse proxy host

Parameters
id Host ID required path reverse_proxy_host_id Reverse Proxy Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Upserts an orchestrator host reverse proxy host http route:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes Authorized

This endpoint upserts an orchestrator host reverse proxy host http route

Parameters
request Upsert Host Reverse Proxy Host Http Routes Request body 
{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes"
  method := "post"
  payload := strings.NewReader(`{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes an orchestrator host reverse proxy host http route:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id} Authorized

This endpoint deletes an orchestrator host reverse proxy host http route

Parameters
id Host ID required path reverse_proxy_host_id Reverse Proxy Host ID required path route_id Route ID required path
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Update an orchestrator host reverse proxy host tcp route:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route Authorized

This endpoint updates an orchestrator host reverse proxy host tcp route

Parameters
request Update Host Reverse Proxy Host tcp Routes Request body 
{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route"
  method := "post"
  payload := strings.NewReader(`{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Restarts orchestrator host reverse proxy:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/restart Authorized

This endpoint restarts orchestrator host reverse proxy

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/restart Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/restart' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/restart");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/restart"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Enables orchestrator host reverse proxy:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/enable Authorized

This endpoint enables orchestrator host reverse proxy

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/enable Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/enable' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/enable");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/enable"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Disables orchestrator host reverse proxy:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/disable Authorized

This endpoint disables orchestrator host reverse proxy

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/disable Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/disable' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/disable");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/disable"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets orchestrator host catalog cache:

/api/v1/orchestrator/hosts/{id}/catalog/cache Authorized

This endpoint returns orchestrator host catalog cache

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/catalog/cache Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes an orchestrator host cache items:

/api/v1/orchestrator/hosts/{id}/catalog/cache Authorized

This endpoint deletes an orchestrator host cache items

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/catalog/cache Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes an orchestrator host cache item and all its children:

/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id} Authorized

This endpoint deletes an orchestrator host cache item and all its children

Parameters
id Host ID required path catalog_id Catalog ID required path
Request examples
/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes an orchestrator host cache item and all its children:

/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version} Authorized

This endpoint deletes an orchestrator host cache item and all its children

Parameters
id Host ID required path catalog_id Catalog ID required path catalog_version Catalog Version required path
Request examples
/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets the orchestrator host system logs from the disk:

/api/v1/orchestrator/hosts/{id}/logs Authorized

This endpoint returns the orchestrator host system logs from the disk

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/logs Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/logs' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/logs");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/logs"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Streams the system logs via WebSocket:

/api/logs/stream Authorized

This endpoint streams the system logs in real-time via WebSocket

Request examples
/logs/stream Authorized 
curl --location 'http://localhost/api/logs/stream' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/logs/stream");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/logs/stream"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Gets all the packer templates:

/api/v1/templates/packer Authorized

This endpoint returns all the packer templates

Request examples
/v1/templates/packer Authorized 
curl --location 'http://localhost/api/v1/templates/packer' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/templates/packer");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/templates/packer"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "addons": "[]string",
    "created_at": "string",
    "defaults": "map[string]string",
    "description": "string",
    "id": "string",
    "internal": "bool",
    "name": "string",
    "packer_folder": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "specs": "map[string]string",
    "updated_at": "string",
    "variables": "map[string]string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets a packer template:

/api/v1/templates/packer/{id} Authorized

This endpoint returns a packer template

Parameters
id Packer Template ID required path
Request examples
/v1/templates/packer/{id} Authorized 
curl --location 'http://localhost/api/v1/templates/packer/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/templates/packer/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/templates/packer/{id}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "addons": "[]string",
    "created_at": "string",
    "defaults": "map[string]string",
    "description": "string",
    "id": "string",
    "internal": "bool",
    "name": "string",
    "packer_folder": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "specs": "map[string]string",
    "updated_at": "string",
    "variables": "map[string]string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates a packer template:

/api/v1/templates/packer Authorized

This endpoint creates a packer template

Parameters
createPackerTemplateRequest Create Packer Template Request body 
{
  "addons": "[]string",
  "created_at": "string",
  "defaults": "map[string]string",
  "description": "string",
  "id": "string",
  "internal": "bool",
  "name": "string",
  "packer_folder": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "specs": "map[string]string",
  "updated_at": "string",
  "variables": "map[string]string"
}
Request examples
/v1/templates/packer Authorized 
curl --location 'http://localhost/api/v1/templates/packer ' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "addons": "[]string",
  "created_at": "string",
  "defaults": "map[string]string",
  "description": "string",
  "id": "string",
  "internal": "bool",
  "name": "string",
  "packer_folder": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "specs": "map[string]string",
  "updated_at": "string",
  "variables": "map[string]string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/templates/packer ");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "addons": "[]string",
  "created_at": "string",
  "defaults": "map[string]string",
  "description": "string",
  "id": "string",
  "internal": "bool",
  "name": "string",
  "packer_folder": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "specs": "map[string]string",
  "updated_at": "string",
  "variables": "map[string]string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/templates/packer "
  method := "post"
  payload := strings.NewReader(`{
  "addons": "[]string",
  "created_at": "string",
  "defaults": "map[string]string",
  "description": "string",
  "id": "string",
  "internal": "bool",
  "name": "string",
  "packer_folder": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "specs": "map[string]string",
  "updated_at": "string",
  "variables": "map[string]string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "addons": "[]string",
    "created_at": "string",
    "defaults": "map[string]string",
    "description": "string",
    "id": "string",
    "internal": "bool",
    "name": "string",
    "packer_folder": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "specs": "map[string]string",
    "updated_at": "string",
    "variables": "map[string]string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Updates a packer template:

/api/v1/templates/packer/{id} Authorized

This endpoint updates a packer template

Parameters
createPackerTemplateRequest Update Packer Template Request body 
{
  "addons": "[]string",
  "created_at": "string",
  "defaults": "map[string]string",
  "description": "string",
  "id": "string",
  "internal": "bool",
  "name": "string",
  "packer_folder": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "specs": "map[string]string",
  "updated_at": "string",
  "variables": "map[string]string"
}
id Packer Template ID required path
Request examples
/v1/templates/packer/{id} Authorized 
curl --location 'http://localhost/api/v1/templates/packer/{id} ' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "addons": "[]string",
  "created_at": "string",
  "defaults": "map[string]string",
  "description": "string",
  "id": "string",
  "internal": "bool",
  "name": "string",
  "packer_folder": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "specs": "map[string]string",
  "updated_at": "string",
  "variables": "map[string]string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/templates/packer/{id} ");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "addons": "[]string",
  "created_at": "string",
  "defaults": "map[string]string",
  "description": "string",
  "id": "string",
  "internal": "bool",
  "name": "string",
  "packer_folder": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "specs": "map[string]string",
  "updated_at": "string",
  "variables": "map[string]string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/templates/packer/{id} "
  method := "PUT"
  payload := strings.NewReader(`{
  "addons": "[]string",
  "created_at": "string",
  "defaults": "map[string]string",
  "description": "string",
  "id": "string",
  "internal": "bool",
  "name": "string",
  "packer_folder": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "specs": "map[string]string",
  "updated_at": "string",
  "variables": "map[string]string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "addons": "[]string",
    "created_at": "string",
    "defaults": "map[string]string",
    "description": "string",
    "id": "string",
    "internal": "bool",
    "name": "string",
    "packer_folder": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "specs": "map[string]string",
    "updated_at": "string",
    "variables": "map[string]string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes a packer template:

/api/v1/templates/packer/{id} Authorized

This endpoint deletes a packer template

Parameters
id Packer Template ID required path
Request examples
/v1/templates/packer/{id} Authorized 
curl --location 'http://localhost/api/v1/templates/packer/{id} ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/templates/packer/{id} ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/templates/packer/{id} "
  method := "DELETE"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets reverse proxy configuration:

/api/v1/reverse-proxy Authorized

This endpoint returns the reverse proxy configuration

Request examples
/v1/reverse-proxy Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/reverse-proxy");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "enabled": "bool",
  "host": "string",
  "port": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the reverse proxy hosts:

/api/v1/reverse-proxy/hosts Authorized

This endpoint returns all the reverse proxy hosts

Request examples
/v1/reverse-proxy/hosts Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/reverse-proxy/hosts");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the reverse proxy host:

/api/v1/reverse-proxy/hosts/{id} Authorized

This endpoint returns a reverse proxy host

Parameters
id Reverse Proxy Host ID required path
Request examples
/v1/reverse-proxy/hosts/{id} Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id} ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/reverse-proxy/hosts/{id} ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts/{id} "
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates a reverse proxy host:

/api/v1/reverse-proxy/hosts Authorized

This endpoint creates a reverse proxy host

Parameters
reverse_proxy_create_request Reverse Host Request body 
{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}
Request examples
/v1/reverse-proxy/hosts Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/reverse-proxy/hosts");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts"
  method := "post"
  payload := strings.NewReader(`{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Updates a reverse proxy host:

/api/v1/reverse-proxy/hosts/{id} Authorized

This endpoint creates a reverse proxy host

Parameters
reverse_proxy_update_request Reverse Host Request body 
{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}
Request examples
/v1/reverse-proxy/hosts/{id} Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/reverse-proxy/hosts/{id}");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts/{id}"
  method := "put"
  payload := strings.NewReader(`{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Delete a a reverse proxy host:

/api/v1/reverse-proxy/hosts/{id} Authorized

This endpoint Deletes a reverse proxy host

Parameters
id Reverse Proxy Host ID required path
Request examples
/v1/reverse-proxy/hosts/{id} Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/reverse-proxy/hosts/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts/{id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates or updates a reverse proxy host HTTP route:

/api/v1/reverse-proxy/hosts/{id}/http_route Authorized

This endpoint creates or updates a reverse proxy host HTTP route

Parameters
reverse_proxy_http_route_request Reverse Host Request body 
{
  "path": "string",
  "pattern": "string",
  "request_headers": "map[string]string",
  "response_headers": "map[string]string",
  "schema": "string",
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}
Request examples
/v1/reverse-proxy/hosts/{id}/http_route Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}/http_route' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "path": "string",
  "pattern": "string",
  "request_headers": "map[string]string",
  "response_headers": "map[string]string",
  "schema": "string",
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_route");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "path": "string",
  "pattern": "string",
  "request_headers": "map[string]string",
  "response_headers": "map[string]string",
  "schema": "string",
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_route"
  method := "post"
  payload := strings.NewReader(`{
  "path": "string",
  "pattern": "string",
  "request_headers": "map[string]string",
  "response_headers": "map[string]string",
  "schema": "string",
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Delete a a reverse proxy host HTTP route:

/api/v1/reverse-proxy/hosts/{id}/http_routes/{http_route_id} Authorized

This endpoint Deletes a reverse proxy host HTTP route

Parameters
id Reverse Proxy Host ID required path http_route_id Reverse Proxy Host HTTP Route ID required path
Request examples
/v1/reverse-proxy/hosts/{id}/http_routes/{http_route_id} Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes/{http_route_id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes/{http_route_id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes/{http_route_id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Updates a reverse proxy host TCP route:

/api/v1/reverse-proxy/hosts/{id}/http_routes Authorized

This endpoint updates a reverse proxy host TCP route

Parameters
reverse_proxy_tcp_route_request Reverse Host Request body 
{
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}
Request examples
/v1/reverse-proxy/hosts/{id}/http_routes Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes"
  method := "post"
  payload := strings.NewReader(`{
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Restarts the reverse proxy:

/api/v1/reverse-proxy/restart Authorized

This endpoint will restart the reverse proxy

Request examples
/v1/reverse-proxy/restart Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/restart' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/reverse-proxy/restart");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/restart"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Enable the reverse proxy:

/api/v1/reverse-proxy/enable Authorized

This endpoint will enable the reverse proxy

Request examples
/v1/reverse-proxy/enable Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/enable' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/reverse-proxy/enable");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/enable"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Disable the reverse proxy:

/api/v1/reverse-proxy/disable Authorized

This endpoint will disable the reverse proxy

Request examples
/v1/reverse-proxy/disable Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/disable' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/reverse-proxy/disable");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/disable"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the roles:

/api/v1/auth/roles Authorized

This endpoint returns all the roles

Request examples
/v1/auth/roles Authorized 
curl --location 'http://localhost/api/v1/auth/roles ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/auth/roles ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/roles "
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "id": "string",
    "name": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets a role:

/api/v1/auth/roles/{id} Authorized

This endpoint returns a role

Parameters
id Role ID required path
Request examples
/v1/auth/roles/{id} Authorized 
curl --location 'http://localhost/api/v1/auth/roles/{id} ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/auth/roles/{id} ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/roles/{id} "
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "id": "string",
    "name": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets a role:

/api/v1/auth/roles Authorized

This endpoint returns a role

Parameters
roleRequest Role Request body 
{
  "name": "string"
}
Request examples
/v1/auth/roles Authorized 
curl --location 'http://localhost/api/v1/auth/roles ' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "name": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/auth/roles ");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "name": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/roles "
  method := "post"
  payload := strings.NewReader(`{
  "name": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "id": "string",
    "name": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Delete a role:

/api/v1/auth/roles/{id} Authorized

This endpoint deletes a role

Parameters
id Role ID required path
Request examples
/v1/auth/roles/{id} Authorized 
curl --location 'http://localhost/api/v1/auth/roles/{id} ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/auth/roles/{id} ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/roles/{id} "
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the users:

/api/v1/auth/users Authorized

This endpoint returns all the users

Request examples
/v1/auth/users Authorized 
curl --location 'http://localhost/api/v1/auth/users ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/auth/users ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/users "
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "claims": "[]string",
    "email": "string",
    "id": "string",
    "isSuperUser": "bool",
    "name": "string",
    "roles": "[]string",
    "username": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets a user:

/api/v1/auth/users/{id} Authorized

This endpoint returns a user

Parameters
id User ID required path
Request examples
/v1/auth/users/{id} Authorized 
curl --location 'http://localhost/api/v1/auth/users/{id} ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/auth/users/{id} ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/users/{id} "
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "claims": "[]string",
    "email": "string",
    "id": "string",
    "isSuperUser": "bool",
    "name": "string",
    "roles": "[]string",
    "username": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates a user:

/api/v1/auth/users Authorized

This endpoint creates a user

Parameters
body User body 
{
  "claims": "[]string",
  "email": "string",
  "is_super_user": "bool",
  "name": "string",
  "password": "string",
  "roles": "[]string",
  "username": "string"
}
Request examples
/v1/auth/users Authorized 
curl --location 'http://localhost/api/v1/auth/users ' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "claims": "[]string",
  "email": "string",
  "is_super_user": "bool",
  "name": "string",
  "password": "string",
  "roles": "[]string",
  "username": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/auth/users ");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "claims": "[]string",
  "email": "string",
  "is_super_user": "bool",
  "name": "string",
  "password": "string",
  "roles": "[]string",
  "username": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/users "
  method := "post"
  payload := strings.NewReader(`{
  "claims": "[]string",
  "email": "string",
  "is_super_user": "bool",
  "name": "string",
  "password": "string",
  "roles": "[]string",
  "username": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "claims": "[]string",
    "email": "string",
    "id": "string",
    "isSuperUser": "bool",
    "name": "string",
    "roles": "[]string",
    "username": "string"
  }
]

{
  "code": "int",
  "diagnostics": {
    "end_time": "*time.Time",
    "errors": [
      {
        "code": "string",
        "component": "string",
        "message": "string",
        "metadata": "map[string]unknown",
        "timestamp": "time.Time"
      }
    ],
    "metadata": "map[string]unknown",
    "mu": "sync.RWMutex",
    "operation": "string",
    "path": [
      {
        "component": "string",
        "duration": "int64",
        "file_name": "string",
        "function_name": "string",
        "line_number": "int",
        "metadata": "map[string]unknown",
        "operation": "string",
        "timestamp": "time.Time"
      }
    ],
    "start_time": "time.Time",
    "warnings": [
      {
        "code": "string",
        "component": "string",
        "message": "string",
        "metadata": "map[string]unknown",
        "timestamp": "time.Time"
      }
    ]
  },
  "message": "string"
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes a user:

/api/v1/auth/users/{id} Authorized

This endpoint deletes a user

Parameters
id User ID required path
Request examples
/v1/auth/users/{id} Authorized 
curl --location 'http://localhost/api/v1/auth/users/{id} ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/auth/users/{id} ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/users/{id} "
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Update a user:

/api/v1/auth/users/{id} Authorized

This endpoint updates a user

Parameters
body User body 
{
  "claims": "[]string",
  "email": "string",
  "is_super_user": "bool",
  "name": "string",
  "password": "string",
  "roles": "[]string",
  "username": "string"
}
Request examples
/v1/auth/users/{id} Authorized 
curl --location 'http://localhost/api/v1/auth/users/{id} ' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "claims": "[]string",
  "email": "string",
  "is_super_user": "bool",
  "name": "string",
  "password": "string",
  "roles": "[]string",
  "username": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/auth/users/{id} ");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "claims": "[]string",
  "email": "string",
  "is_super_user": "bool",
  "name": "string",
  "password": "string",
  "roles": "[]string",
  "username": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/users/{id} "
  method := "put"
  payload := strings.NewReader(`{
  "claims": "[]string",
  "email": "string",
  "is_super_user": "bool",
  "name": "string",
  "password": "string",
  "roles": "[]string",
  "username": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "claims": "[]string",
    "email": "string",
    "id": "string",
    "isSuperUser": "bool",
    "name": "string",
    "roles": "[]string",
    "username": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the roles for a user:

/api/v1/auth/users/{id}/roles Authorized

This endpoint returns all the roles for a user

Parameters
id User ID required path
Request examples
/v1/auth/users/{id}/roles Authorized 
curl --location 'http://localhost/api/v1/auth/users/{id}/roles ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/auth/users/{id}/roles ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/users/{id}/roles "
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "id": "string",
    "name": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Adds a role to a user:

/api/v1/auth/users/{id}/roles Authorized

This endpoint adds a role to a user

Parameters
id User ID required path
body Role Name body 
{
  "name": "string"
}
Request examples
/v1/auth/users/{id}/roles Authorized 
curl --location 'http://localhost/api/v1/auth/users/{id}/roles ' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "name": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/auth/users/{id}/roles ");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "name": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/users/{id}/roles "
  method := "post"
  payload := strings.NewReader(`{
  "name": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "name": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Removes a role from a user:

/api/v1/auth/users/{id}/roles/{role_id} Authorized

This endpoint removes a role from a user

Parameters
id User ID required path role_id Role ID required path
Request examples
/v1/auth/users/{id}/roles/{role_id} Authorized 
curl --location 'http://localhost/api/v1/auth/users/{id}/roles/{role_id} ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/auth/users/{id}/roles/{role_id} ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/users/{id}/roles/{role_id} "
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the claims for a user:

/api/v1/auth/users/{id}/claims Authorized

This endpoint returns all the claims for a user

Parameters
id User ID required path
Request examples
/v1/auth/users/{id}/claims Authorized 
curl --location 'http://localhost/api/v1/auth/users/{id}/claims ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/auth/users/{id}/claims ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/users/{id}/claims "
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "id": "string",
    "name": "string"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Adds a claim to a user:

/api/v1/auth/users/{id}/claims Authorized

This endpoint adds a claim to a user

Parameters
id User ID required path
body Claim Name body 
{
  "name": "string"
}
Request examples
/v1/auth/users/{id}/claims Authorized 
curl --location 'http://localhost/api/v1/auth/users/{id}/claims ' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "name": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/auth/users/{id}/claims ");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "name": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/users/{id}/claims "
  method := "post"
  payload := strings.NewReader(`{
  "name": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "name": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Removes a claim from a user:

/api/v1/auth/users/{id}/claims/{claim_id} Authorized

This endpoint removes a claim from a user

Parameters
id User ID required path claim_id Claim ID required path
Request examples
/v1/auth/users/{id}/claims/{claim_id} Authorized 
curl --location 'http://localhost/api/v1/auth/users/{id}/claims/{claim_id} ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/auth/users/{id}/claims/{claim_id} ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/auth/users/{id}/claims/{claim_id} "
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets the API Health Probe:

/api/health/probe Authorized

This endpoint returns the API Health Probe

Request examples
/health/probe Authorized 
curl --location 'http://localhost/api/health/probe' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/health/probe");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/health/probe"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "additionalProp1": "string",
  "additionalProp2": "string",
  "additionalProp3": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}