Gets catalog cache

/api/v1/cache Authorized

This endpoint returns all the remote catalog cache if any

Request examples

      
      /v1/cache
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

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

var client = new HttpClient();

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

{ object }

{ object }

{ object }

Deletes all catalog cache

/api/v1/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/cache
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

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

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/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/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

{ object }

{ object }

Deletes catalog cache item and all its versions

/api/v1/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/cache/{catalogId}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/cache/{catalogId}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/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/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

{ object }

{ object }

Deletes catalog cache version item

/api/v1/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/cache/{catalogId}/{version}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/cache/{catalogId}/{version}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/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/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

{ object }

{ object }

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

{ object }

{ object }

{ object }

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

{ object }

{ object }

{ object }

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

{ object }

{ object }

{ object }

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

{ object }

{ object }

{ object }

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

{ object }

{ object }

{ object }

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

{ object }

{ object }

{ object }

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

{ object }

{ object }

{ object }

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

{ object }

{ object }

{ object }

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 `{ object }`

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 '{ object }'

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("{ object }");
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(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

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 `{ object }`

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 '{ object }'

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("{ object }");
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(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

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 `{ object }`

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 '{ object }'

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("{ object }");
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(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

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 `{ object }`

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 '{ object }'

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("{ object }");
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(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

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 `{ object }`

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 '{ object }'

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("{ object }");
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(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

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 `{ object }`

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 '{ object }'

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("{ object }");
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(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

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

{ object }

{ object }

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

{ object }

{ object }

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

{ object }

{ object }

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
Schema `{ object }`

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 '{ object }'

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("{ object }");
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(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

Push a catalog manifest to the catalog inventory asynchronously

/api/v1/catalog/push/async Authorized

This endpoint pushes a catalog manifest to the catalog inventory in the background and returns a Job ID to track progress

Parameters

Name	Type	In	Required	Description
`pushRequest`	`object`	body	optional	Push request
Schema `{ object }`

Request examples

      
      /v1/catalog/push/async
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/catalog/push/async' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/catalog/push/async");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
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/async"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

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
Schema `{ object }`

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 '{ object }'

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("{ object }");
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(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

Pull a remote catalog manifest asynchronously

/api/v1/catalog/pull/async Authorized

This endpoint pulls a remote catalog manifest in the background and returns a Job ID to track progress

Parameters

Name	Type	In	Required	Description
`pullRequest`	`object`	body	optional	Pull request
Schema `{ object }`

Request examples

      
      /v1/catalog/pull/async
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/catalog/pull/async' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/catalog/pull/async");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
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/async"
  method := "put"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

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 `{ object }`

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 '{ object }'

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("{ object }");
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(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

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
Schema `{ object }`

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 '{ object }'

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("{ object }");
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(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

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 `{ object }`

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 '{ object }'

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("{ object }");
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(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

Updates metadata for a catalog manifest version

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

This endpoint atomically updates description, tags, required claims, and required roles for a catalog manifest version. Omit a field to leave it unchanged.

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 `{ object }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/metadata' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/catalog/{catalogId}/{version}/{architecture}/metadata");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
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}/metadata"
  method := "put"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

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

Responses

{ object }

{ object }

{ object }

Catalogs endpoints

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

Push a catalog manifest to the catalog inventory asynchronously

Parameters

Pull a remote catalog manifest

Parameters

Pull a remote catalog manifest asynchronously

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

Updates metadata for a catalog manifest version

Parameters

Cookie Consent