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

Name	Type	Required	Description
`x-filter`	`header`	optional	Filter entities

Parameters

Name	Type	In	Required	Description
`apiKey`	`object`	body	optional	Body
Schema `{ "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Api Key ID

Request examples

      
      /v1/auth/api_keys/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Api Key ID

Request examples

      
      /v1/auth/api_keys/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Api Key ID

Request examples

      
      /v1/auth/api_keys/{id}/revoke
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`login`	`object`	body	optional	Body
Schema `{ "email": "string", "password": "string" }`

Request examples

      
      /v1/auth/token
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`tokenRequest`	`object`	body	optional	Body
Schema `{ "token": "string" }`

Request examples

      
      /v1/auth/token/validate
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID

Request examples

      
      /v1/catalog/{catalogId}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version
`architecture`	`string`	path	required	Architecture

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version
`architecture`	`string`	path	required	Architecture

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version
`architecture`	`string`	path	required	Architecture

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version
`architecture`	`string`	path	required	Architecture

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version
`architecture`	`string`	path	required	Architecture

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version
`architecture`	`string`	path	required	Architecture
`request`	`object`	body	optional	Body
Schema `{ "connection": "string", "required_claims": "[]string", "required_roles": "[]string", "tags": "[]string" }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version
`architecture`	`string`	path	required	Architecture
`request`	`object`	body	optional	Body
Schema `{ "connection": "string", "required_claims": "[]string", "required_roles": "[]string", "tags": "[]string" }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version
`architecture`	`string`	path	required	Architecture
`request`	`object`	body	optional	Body
Schema `{ "connection": "string", "required_claims": "[]string", "required_roles": "[]string", "tags": "[]string" }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version
`architecture`	`string`	path	required	Architecture
`request`	`object`	body	optional	Body
Schema `{ "connection": "string", "required_claims": "[]string", "required_roles": "[]string", "tags": "[]string" }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version
`architecture`	`string`	path	required	Architecture
`request`	`object`	body	optional	Body
Schema `{ "connection": "string", "required_claims": "[]string", "required_roles": "[]string", "tags": "[]string" }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version
`architecture`	`string`	path	required	Architecture
`request`	`object`	body	optional	Body
Schema `{ "connection": "string", "required_claims": "[]string", "required_roles": "[]string", "tags": "[]string" }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID

Request examples

      
      /v1/catalog/{catalogId}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version
`architecture`	`string`	path	required	Architecture

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name Type In Required Description

pushRequest object body optional Push request

Name	Type	In	Required	Description
`pushRequest`	`object`	body	optional	Push request
Schema `{ "architecture": "string", "catalog_id": "string", "compress_pack": "bool", "compress_pack_level": "int", "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" }`

Schema

{
  "architecture": "string",
  "catalog_id": "string",
  "compress_pack": "bool",
  "compress_pack_level": "int",
  "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
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/catalog/push' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "architecture": "string",
  "catalog_id": "string",
  "compress_pack": "bool",
  "compress_pack_level": "int",
  "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",
  "compress_pack_level": "int",
  "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",
  "compress_pack_level": "int",
  "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

Name Type In Required Description

pullRequest object body optional Pull request

Name	Type	In	Required	Description
`pullRequest`	`object`	body	optional	Pull request
Schema `{ "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" }`

Schema

{
  "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`importRequest`	`object`	body	optional	Pull request
Schema `{ "architecture": "string", "catalog_id": "string", "connection": "string", "provider_metadata": "map[string]string", "version": "string" }`

Request examples

      
      /v1/catalog/import
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name Type In Required Description

importRequest object body optional Vm Impoty request

Name	Type	In	Required	Description
`importRequest`	`object`	body	optional	Vm Impoty request
Schema `{ "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" }`

Schema

{
  "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`request`	`object`	body	optional	Body
Schema `{ "connection": "string", "required_claims": "[]string", "required_roles": "[]string", "tags": "[]string" }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID

Request examples

      
      /v1/catalog/cache
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID

Request examples

      
      /v1/catalog/cache/{catalogId}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`catalogId`	`string`	path	required	Catalog ID
`version`	`string`	path	required	Version

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Claim ID

Request examples

      
      /v1/auth/claims/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`claimRequest`	`object`	body	optional	Claim Request
Schema `{ "name": "string" }`

Request examples

      
      /v1/auth/claims
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Claim ID

Request examples

      
      /v1/auth/claims/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`installToolsRequest`	`object`	body	optional	Install Tools Request
Schema `{ "all": "bool", "run_as": "string", "tools": "map[string]InstallToolsRequestItem" }`

Request examples

      
      /v1/config/tools/install
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`uninstallToolsRequest`	`object`	body	optional	Uninstall Tools Request
Schema `{ "all": "bool", "run_as": "string", "tools": "map[string]UninstallToolsRequestItem", "uninstall_dependencies": "bool" }`

Request examples

      
      /v1/config/tools/uninstall
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`full`	`query`	query	optional	-

Request examples

      
      /health/system
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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"
}

Subscribe to event notifications via WebSocket

/api/v1/ws/subscribe Authorized

This endpoint upgrades the HTTP connection to WebSocket and subscribes to event notifications. Authentication is required via Authorization header (Bearer token) or X-Api-Key header.

Parameters

Name	Type	In	Required	Description
`event_types`	`query`	query	optional	-

Request examples

      
      /v1/ws/subscribe
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/ws/subscribe' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/ws/subscribe");
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/ws/subscribe"
  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"
    }
  ]
}

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

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

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

Unsubscribe from specific event types

/api/v1/ws/unsubscribe Authorized

Unsubscribe an active WebSocket client from specific event types without disconnecting. The client must belong to the authenticated user.

Parameters

Name	Type	In	Required	Description
`body`	`object`	body	optional	Unsubscribe request with client ID and event types
Schema `{ "client_id": "string", "event_types": "[]string", "user_id": "string" }`

Request examples

      
      /v1/ws/unsubscribe
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/ws/unsubscribe' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "client_id": "string",
  "event_types": "[]string",
  "user_id": "string"
}'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/ws/unsubscribe");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "client_id": "string",
  "event_types": "[]string",
  "user_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/ws/unsubscribe"
  method := "post"
  payload := strings.NewReader(`{
  "client_id": "string",
  "event_types": "[]string",
  "user_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

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

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

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

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

Gets all the virtual machines

/api/v1/machines Authorized

This endpoint returns all the virtual machines

Parameters

Name	Type	In	Required	Description
`filter`	`header`	header	optional	-

Request examples

      
      /v1/machines
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID

Request examples

      
      /v1/machines/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID

Request examples

      
      /v1/machines/{id}/start
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID

Request examples

      
      /v1/machines/{id}/stop
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID

Request examples

      
      /v1/machines/{id}/restart
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID

Request examples

      
      /v1/machines/{id}/suspend
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID

Request examples

      
      /v1/machines/{id}/resume
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID

Request examples

      
      /v1/machines/{id}/reset
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID

Request examples

      
      /v1/machines/{id}/pause
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID

Request examples

      
      /v1/machines/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID

Request examples

      
      /v1/machines/{id}/status
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`configRequest`	`object`	body	optional	Machine Set Request
Schema `{ "operations": "[]*VirtualMachineConfigRequestOperation", "owner": "string" }`

Request examples

      
      /v1/machines/{id}/set
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`configRequest`	`object`	body	optional	Machine Clone Request
Schema `{ "clone_name": "string" }`

Request examples

      
      /v1/machines/{id}/clone
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`executeRequest`	`object`	body	optional	Machine Execute Command Request
Schema `{ "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`executeRequest`	`object`	body	optional	Machine Upload file Command Request
Schema `{ "path": "string", "remote_path": "string" }`

Request examples

      
      /v1/machines/{id}/upload
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`renameRequest`	`object`	body	optional	Machine Rename Request
Schema `{ "current_name": "string", "description": "string", "id": "string", "new_name": "string" }`

Request examples

      
      /v1/machines/{id}/rename
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`registerRequest`	`object`	body	optional	Machine Register Request
Schema `{ "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`unregisterRequest`	`object`	body	optional	Machine Unregister Request
Schema `{ "clean_source_uuid": "bool", "id": "string", "owner": "string" }`

Request examples

      
      /v1/machines/{id}/unregister
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name Type In Required Description

createRequest object body optional New Machine Request

Schema

{
  "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name Type In Required Description

hostRequest object body optional Host Request

Schema

{
  "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`hostRequest`	`object`	body	optional	Host Update Request
Schema `{ "authentication": "*OrchestratorAuthentication", "description": "string", "host": "string", "port": "string", "prefix": "string", "schema": "string" }`

Request examples

      
      /v1/orchestrator/hosts
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`request`	`object`	body	optional	Register Virtual Machine Request
Schema `{ "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID
`request`	`object`	body	optional	Register Virtual Machine Request
Schema `{ "clean_source_uuid": "bool", "id": "string", "owner": "string" }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name Type In Required Description

id string path required Host ID

request object body optional Create Virtual Machine Request

Schema

{
  "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name Type In Required Description

request object body optional Create Virtual Machine Request

Schema

{
  "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`request`	`object`	body	optional	Create Host Reverse Proxy Host Request
Schema `{ "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`request`	`object`	body	optional	Update Host Reverse Proxy Host Request
Schema `{ "cors": "ReverseProxyHostCors", "host": "string", "port": "string", "tls": "ReverseProxyHostTls" }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`reverse_proxy_host_id`	`string`	path	required	Reverse Proxy Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`request`	`object`	body	optional	Upsert Host Reverse Proxy Host Http Routes Request
Schema `{ "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`reverse_proxy_host_id`	`string`	path	required	Reverse Proxy Host ID
`route_id`	`string`	path	required	Route ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`request`	`object`	body	optional	Update Host Reverse Proxy Host tcp Routes Request
Schema `{ "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/catalog/cache
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/catalog/cache
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`catalog_id`	`string`	path	required	Catalog ID

Request examples

      
      /v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`catalog_id`	`string`	path	required	Catalog ID
`catalog_version`	`string`	path	required	Catalog Version

Request examples

      
      /v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Packer Template ID

Request examples

      
      /v1/templates/packer/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name Type In Required Description

createPackerTemplateRequest object body optional Create Packer Template Request

Schema

{
  "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name Type In Required Description

createPackerTemplateRequest object body optional Update Packer Template Request

Schema

{
  "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 string path required Packer Template ID

Request examples

      
      /v1/templates/packer/{id} 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Packer Template ID

Request examples

      
      /v1/templates/packer/{id} 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Reverse Proxy Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`reverse_proxy_create_request`	`object`	body	optional	Reverse Host Request
Schema `{ "cors": "ReverseProxyHostCors", "host": "string", "http_routes": "[]ReverseProxyHostHttpRoute", "port": "string", "tcp_route": "ReverseProxyHostTcpRoute", "tls": "ReverseProxyHostTls" }`

Request examples

      
      /v1/reverse-proxy/hosts
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`reverse_proxy_update_request`	`object`	body	optional	Reverse Host Request
Schema `{ "cors": "ReverseProxyHostCors", "host": "string", "port": "string", "tls": "ReverseProxyHostTls" }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Reverse Proxy Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name Type In Required Description

reverse_proxy_http_route_request object body optional Reverse Host Request

Schema

{
  "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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Reverse Proxy Host ID
`http_route_id`	`string`	path	required	Reverse Proxy Host HTTP Route ID

Request examples

      
      /v1/reverse-proxy/hosts/{id}/http_routes/{http_route_id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`reverse_proxy_tcp_route_request`	`object`	body	optional	Reverse Host Request
Schema `{ "target_host": "string", "target_port": "string", "target_vm_id": "string" }`

Request examples

      
      /v1/reverse-proxy/hosts/{id}/http_routes
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Role ID

Request examples

      
      /v1/auth/roles/{id} 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`roleRequest`	`object`	body	optional	Role Request
Schema `{ "name": "string" }`

Request examples

      
      /v1/auth/roles 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Role ID

Request examples

      
      /v1/auth/roles/{id} 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	User ID

Request examples

      
      /v1/auth/users/{id} 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`body`	`object`	body	optional	User
Schema `{ "claims": "[]string", "email": "string", "is_super_user": "bool", "name": "string", "password": "string", "roles": "[]string", "username": "string" }`

Request examples

      
      /v1/auth/users 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	User ID

Request examples

      
      /v1/auth/users/{id} 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`body`	`object`	body	optional	User
Schema `{ "claims": "[]string", "email": "string", "is_super_user": "bool", "name": "string", "password": "string", "roles": "[]string", "username": "string" }`

Request examples

      
      /v1/auth/users/{id} 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	User ID

Request examples

      
      /v1/auth/users/{id}/roles 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	User ID
`body`	`object`	body	optional	Role Name
Schema `{ "name": "string" }`

Request examples

      
      /v1/auth/users/{id}/roles 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	User ID
`role_id`	`string`	path	required	Role ID

Request examples

      
      /v1/auth/users/{id}/roles/{role_id} 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	User ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	User ID
`body`	`object`	body	optional	Claim Name
Schema `{ "name": "string" }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	User ID
`claim_id`	`string`	path	required	Claim ID

Request examples

      
      /v1/auth/users/{id}/claims/{claim_id} 
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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"
}

API Documentation

Creates an api key

This endpoint will create an api key in the system

How are they different from a user?

Headers

Parameters

Gets all the api keys

Deletes an api key

Parameters

Gets an api key by id or name

Parameters

Revoke an api key

Parameters

Generates a token

Parameters

Validates a token

Parameters

Gets all the remote catalogs

Gets all the remote catalogs

Parameters

Gets a catalog manifest version

Parameters

Gets a catalog manifest version architecture

Parameters

Downloads a catalog manifest version

Parameters

Taints a catalog manifest version

Parameters

UnTaints a catalog manifest version

Parameters

UnTaints a catalog manifest version

Parameters

Adds claims to a catalog manifest version

Parameters

Removes claims from a catalog manifest version

Parameters

Adds roles to a catalog manifest version

Parameters

Removes roles from a catalog manifest version

Parameters

Adds tags to a catalog manifest version

Parameters

Removes tags from a catalog manifest version

Parameters

Deletes a catalog manifest and all its versions

Parameters

Deletes a catalog manifest version

Parameters

Deletes a catalog manifest version architecture

Parameters

Pushes a catalog manifest to the catalog inventory

Parameters

Pull a remote catalog manifest

Parameters

Imports a remote catalog manifest metadata into the catalog inventory

Parameters

Imports a vm into the catalog inventory generating the metadata for it

Parameters

Updates a catalog

Parameters

Gets catalog cache

Deletes all catalog cache

Parameters

Deletes catalog cache item and all its versions

Parameters

Deletes catalog cache version item

Parameters

Gets all the claims

Gets a claim

Parameters

Creates a claim

Parameters

Delete a claim

Parameters

Gets Parallels Desktop active license

Installs API requires 3rd party tools

Parameters

Uninstalls API requires 3rd party tools

Parameters

Restarts the API Service