Get Started

Catalogs

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

Catalogs endpoints

This document contains the endpoints for the Catalogs category.

Gets all the remote catalogs:

/api/v1/catalog Authorized

This endpoint returns all the remote catalogs

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


var client = new HttpClient();

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


package main

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

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

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

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

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

/api/v1/catalog/{catalogId} Authorized

This endpoint returns all the remote catalogs

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint returns a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint returns a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint downloads a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint Taints a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint UnTaints a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint UnTaints a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint adds claims to a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint removes claims from a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint adds roles to a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint removes roles from a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint adds tags to a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint removes tags from a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

/api/v1/catalog/{catalogId} Authorized

This endpoint deletes a catalog manifest and all its versions

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


var client = new HttpClient();

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


package main

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

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

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

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

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

This endpoint deletes a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

This endpoint deletes a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

/api/v1/catalog/push Authorized

This endpoint pushes a catalog manifest to the catalog inventory

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


var client = new HttpClient();

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


package main

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

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

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

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

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

/api/v1/catalog/pull Authorized

This endpoint pulls a remote catalog manifest

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


var client = new HttpClient();

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


package main

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

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

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

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

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

/api/v1/catalog/import Authorized

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

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


var client = new HttpClient();

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


package main

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

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

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

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

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

/api/v1/catalog/import-vm Authorized

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

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

This endpoint adds claims to a catalog manifest version

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


var client = new HttpClient();

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


package main

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

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

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

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

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

/api/v1/catalog/cache Authorized

This endpoint returns all the remote catalog cache if any

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


var client = new HttpClient();

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


package main

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

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

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

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

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

/api/v1/catalog/cache Authorized

This endpoint returns all the remote catalog cache if any

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


var client = new HttpClient();

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


package main

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

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

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

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

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

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

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


var client = new HttpClient();

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


package main

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

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

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

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

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

This endpoint deletes a version of a cache ite,

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


var client = new HttpClient();

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


package main

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

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

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}