mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
1125 lines
40 KiB
Go
1125 lines
40 KiB
Go
/*
|
|
Hanzo Cloud API
|
|
|
|
The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
|
|
|
|
API version: v1
|
|
*/
|
|
|
|
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
|
|
|
|
package hanzoai
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
)
|
|
|
|
// LicensingAPIService LicensingAPI service
|
|
type LicensingAPIService service
|
|
|
|
type LicensingAPIGetLicensingDownloadByReleaseRequest struct {
|
|
ctx context.Context
|
|
ApiService *LicensingAPIService
|
|
release string
|
|
xLicenseToken *string
|
|
token *string
|
|
}
|
|
|
|
func (r LicensingAPIGetLicensingDownloadByReleaseRequest) XLicenseToken(xLicenseToken string) LicensingAPIGetLicensingDownloadByReleaseRequest {
|
|
r.xLicenseToken = &xLicenseToken
|
|
return r
|
|
}
|
|
|
|
func (r LicensingAPIGetLicensingDownloadByReleaseRequest) Token(token string) LicensingAPIGetLicensingDownloadByReleaseRequest {
|
|
r.token = &token
|
|
return r
|
|
}
|
|
|
|
func (r LicensingAPIGetLicensingDownloadByReleaseRequest) Execute() (*LicensingReleaseAsset, *http.Response, error) {
|
|
return r.ApiService.GetLicensingDownloadByReleaseExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLicensingDownloadByRelease Download resolves a release to its artifact, gated on a valid license.
|
|
|
|
Download resolves a release to its artifact, gated on a valid license.
|
|
|
|
The gate is the LICENSE token, not the IAM bearer: being signed in is not
|
|
permission to download a paid binary — holding a good license for it is. The
|
|
token must verify against this deployment's public key, be unrevoked, be
|
|
scoped to the release's app, and carry every feature the release requires.
|
|
Present it as the `X-License-Token` header (preferred, since a header does not
|
|
land in proxy logs) or as `?token=`.
|
|
|
|
The response pairs the artifact URL with its cosign signature so the client
|
|
verifies the binary BEFORE trusting it: a signed URL alone proves where the
|
|
bytes came from, not what they are. A yanked release is 410 Gone.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param release
|
|
@return LicensingAPIGetLicensingDownloadByReleaseRequest
|
|
*/
|
|
func (a *LicensingAPIService) GetLicensingDownloadByRelease(ctx context.Context, release string) LicensingAPIGetLicensingDownloadByReleaseRequest {
|
|
return LicensingAPIGetLicensingDownloadByReleaseRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
release: release,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LicensingReleaseAsset
|
|
func (a *LicensingAPIService) GetLicensingDownloadByReleaseExecute(r LicensingAPIGetLicensingDownloadByReleaseRequest) (*LicensingReleaseAsset, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LicensingReleaseAsset
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LicensingAPIService.GetLicensingDownloadByRelease")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/licensing/download/{release}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"release"+"}", url.PathEscape(parameterValueToString(r.release, "release")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.token != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "token", r.token, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
if r.xLicenseToken != nil {
|
|
parameterAddToHeaderOrQuery(localVarHeaderParams, "X-License-Token", r.xLicenseToken, "simple", "")
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type LicensingAPIGetLicensingHealthzRequest struct {
|
|
ctx context.Context
|
|
ApiService *LicensingAPIService
|
|
}
|
|
|
|
func (r LicensingAPIGetLicensingHealthzRequest) Execute() (*LicensingHealthView, *http.Response, error) {
|
|
return r.ApiService.GetLicensingHealthzExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLicensingHealthz Health reports which signer this deployment mints with, and in which env.
|
|
|
|
Health reports which signer this deployment mints with, and in which env.
|
|
|
|
It answers 200 whenever the process is up: there is nothing downstream to
|
|
probe, since KMS is read only when a token is actually minted. Its
|
|
value is the `signer` field — `"signer":"local"` on a production host says
|
|
that deployment is signing licenses with a development key, which is a
|
|
misconfiguration worth paging on rather than a healthy 200.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LicensingAPIGetLicensingHealthzRequest
|
|
*/
|
|
func (a *LicensingAPIService) GetLicensingHealthz(ctx context.Context) LicensingAPIGetLicensingHealthzRequest {
|
|
return LicensingAPIGetLicensingHealthzRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LicensingHealthView
|
|
func (a *LicensingAPIService) GetLicensingHealthzExecute(r LicensingAPIGetLicensingHealthzRequest) (*LicensingHealthView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LicensingHealthView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LicensingAPIService.GetLicensingHealthz")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/licensing/healthz"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type LicensingAPIGetLicensingJwksRequest struct {
|
|
ctx context.Context
|
|
ApiService *LicensingAPIService
|
|
}
|
|
|
|
func (r LicensingAPIGetLicensingJwksRequest) Execute() (*LicensingPubkeyView, *http.Response, error) {
|
|
return r.ApiService.GetLicensingJwksExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLicensingJwks Pubkey publishes the Ed25519 PUBLIC verification key, at both /pubkey and /jwks.
|
|
|
|
Pubkey publishes the Ed25519 PUBLIC verification key, at both /pubkey and
|
|
/jwks.
|
|
|
|
This is the only public-safe surface here and the reason the whole scheme
|
|
works offline: the engine embeds or fetches this key once and then verifies
|
|
every license itself, with no call home per launch. The private half lives in
|
|
KMS, so nothing served here is a secret. `provider` names where that half
|
|
lives: `"kms"` is the production key every engine embeds; `"local"` is a
|
|
development key, and a token signed by one is not a production credential.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LicensingAPIGetLicensingJwksRequest
|
|
*/
|
|
func (a *LicensingAPIService) GetLicensingJwks(ctx context.Context) LicensingAPIGetLicensingJwksRequest {
|
|
return LicensingAPIGetLicensingJwksRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LicensingPubkeyView
|
|
func (a *LicensingAPIService) GetLicensingJwksExecute(r LicensingAPIGetLicensingJwksRequest) (*LicensingPubkeyView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LicensingPubkeyView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LicensingAPIService.GetLicensingJwks")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/licensing/jwks"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type LicensingAPIGetLicensingPubkeyRequest struct {
|
|
ctx context.Context
|
|
ApiService *LicensingAPIService
|
|
}
|
|
|
|
func (r LicensingAPIGetLicensingPubkeyRequest) Execute() (*LicensingPubkeyView, *http.Response, error) {
|
|
return r.ApiService.GetLicensingPubkeyExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLicensingPubkey Pubkey publishes the Ed25519 PUBLIC verification key, at both /pubkey and /jwks.
|
|
|
|
Pubkey publishes the Ed25519 PUBLIC verification key, at both /pubkey and
|
|
/jwks.
|
|
|
|
This is the only public-safe surface here and the reason the whole scheme
|
|
works offline: the engine embeds or fetches this key once and then verifies
|
|
every license itself, with no call home per launch. The private half lives in
|
|
KMS, so nothing served here is a secret. `provider` names where that half
|
|
lives: `"kms"` is the production key every engine embeds; `"local"` is a
|
|
development key, and a token signed by one is not a production credential.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LicensingAPIGetLicensingPubkeyRequest
|
|
*/
|
|
func (a *LicensingAPIService) GetLicensingPubkey(ctx context.Context) LicensingAPIGetLicensingPubkeyRequest {
|
|
return LicensingAPIGetLicensingPubkeyRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LicensingPubkeyView
|
|
func (a *LicensingAPIService) GetLicensingPubkeyExecute(r LicensingAPIGetLicensingPubkeyRequest) (*LicensingPubkeyView, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LicensingPubkeyView
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LicensingAPIService.GetLicensingPubkey")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/licensing/pubkey"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type LicensingAPIGetLicensingReleasesRequest struct {
|
|
ctx context.Context
|
|
ApiService *LicensingAPIService
|
|
}
|
|
|
|
func (r LicensingAPIGetLicensingReleasesRequest) Execute() (*LicensingReleaseList, *http.Response, error) {
|
|
return r.ApiService.GetLicensingReleasesExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLicensingReleases Lists the signed binary releases this deployment can serve.
|
|
|
|
Lists the signed binary releases this deployment can serve.
|
|
|
|
Metadata only, and no download URL: the artifact is behind GET
|
|
/v1/licensing/download/{release}, which is gated on a valid license token.
|
|
Knowing that a release exists is not permission to run it, which is why this
|
|
list needs no license of its own.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LicensingAPIGetLicensingReleasesRequest
|
|
*/
|
|
func (a *LicensingAPIService) GetLicensingReleases(ctx context.Context) LicensingAPIGetLicensingReleasesRequest {
|
|
return LicensingAPIGetLicensingReleasesRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LicensingReleaseList
|
|
func (a *LicensingAPIService) GetLicensingReleasesExecute(r LicensingAPIGetLicensingReleasesRequest) (*LicensingReleaseList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LicensingReleaseList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LicensingAPIService.GetLicensingReleases")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/licensing/releases"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type LicensingAPIGetLicensingReleasesByReleaseRequest struct {
|
|
ctx context.Context
|
|
ApiService *LicensingAPIService
|
|
release string
|
|
}
|
|
|
|
func (r LicensingAPIGetLicensingReleasesByReleaseRequest) Execute() (*LicensingRelease, *http.Response, error) {
|
|
return r.ApiService.GetLicensingReleasesByReleaseExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetLicensingReleasesByRelease Reads one release's metadata: its product, version, platform and the cosign material a client verifies the binary against.
|
|
|
|
Reads one release's metadata: its product, version, platform and the
|
|
cosign material a client verifies the binary against.
|
|
|
|
An unknown id is 404. Like the list, this is metadata only — the bytes are
|
|
behind the license-gated download.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param release
|
|
@return LicensingAPIGetLicensingReleasesByReleaseRequest
|
|
*/
|
|
func (a *LicensingAPIService) GetLicensingReleasesByRelease(ctx context.Context, release string) LicensingAPIGetLicensingReleasesByReleaseRequest {
|
|
return LicensingAPIGetLicensingReleasesByReleaseRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
release: release,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LicensingRelease
|
|
func (a *LicensingAPIService) GetLicensingReleasesByReleaseExecute(r LicensingAPIGetLicensingReleasesByReleaseRequest) (*LicensingRelease, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LicensingRelease
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LicensingAPIService.GetLicensingReleasesByRelease")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/licensing/releases/{release}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"release"+"}", url.PathEscape(parameterValueToString(r.release, "release")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type LicensingAPIPostLicensingFingerprintRequest struct {
|
|
ctx context.Context
|
|
ApiService *LicensingAPIService
|
|
licensingFingerprintRequest *LicensingFingerprintRequest
|
|
}
|
|
|
|
func (r LicensingAPIPostLicensingFingerprintRequest) LicensingFingerprintRequest(licensingFingerprintRequest LicensingFingerprintRequest) LicensingAPIPostLicensingFingerprintRequest {
|
|
r.licensingFingerprintRequest = &licensingFingerprintRequest
|
|
return r
|
|
}
|
|
|
|
func (r LicensingAPIPostLicensingFingerprintRequest) Execute() (*LicensingFingerprintResponse, *http.Response, error) {
|
|
return r.ApiService.PostLicensingFingerprintExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostLicensingFingerprint Fingerprint turns raw device signals into the opaque value that binds a license to one machine.
|
|
|
|
Fingerprint turns raw device signals into the opaque value that binds a license
|
|
to one machine.
|
|
|
|
This is the anti-copy step: the value returned here is folded into the signed
|
|
token, so a token minted with it runs only on the device it was bound to. The
|
|
derivation is one-way and salted — the signals are never stored and never
|
|
echoed back — so the response is safe to persist client-side and pass to
|
|
issue. Signals too weak to identify a machine (a hostname alone) are refused
|
|
rather than turned into a binding that would collide with other machines.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LicensingAPIPostLicensingFingerprintRequest
|
|
*/
|
|
func (a *LicensingAPIService) PostLicensingFingerprint(ctx context.Context) LicensingAPIPostLicensingFingerprintRequest {
|
|
return LicensingAPIPostLicensingFingerprintRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LicensingFingerprintResponse
|
|
func (a *LicensingAPIService) PostLicensingFingerprintExecute(r LicensingAPIPostLicensingFingerprintRequest) (*LicensingFingerprintResponse, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LicensingFingerprintResponse
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LicensingAPIService.PostLicensingFingerprint")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/licensing/fingerprint"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.licensingFingerprintRequest == nil {
|
|
return localVarReturnValue, nil, reportError("licensingFingerprintRequest is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.licensingFingerprintRequest
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type LicensingAPIPostLicensingIssueRequest struct {
|
|
ctx context.Context
|
|
ApiService *LicensingAPIService
|
|
licensingIssueRequest *LicensingIssueRequest
|
|
}
|
|
|
|
func (r LicensingAPIPostLicensingIssueRequest) LicensingIssueRequest(licensingIssueRequest LicensingIssueRequest) LicensingAPIPostLicensingIssueRequest {
|
|
r.licensingIssueRequest = &licensingIssueRequest
|
|
return r
|
|
}
|
|
|
|
func (r LicensingAPIPostLicensingIssueRequest) Execute() (*LicensingIssueResponse, *http.Response, error) {
|
|
return r.ApiService.PostLicensingIssueExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostLicensingIssue Issue mints a signed license token for a product the caller's org already pays for.
|
|
|
|
Issue mints a signed license token for a product the caller's org already pays
|
|
for.
|
|
|
|
The order is the whole security argument: the caller is an IAM-validated
|
|
principal, commerce is then asked whether that principal's ORG holds an ACTIVE
|
|
entitlement for the product, and only then is a token signed, with the
|
|
production key KMS holds. A product the org does not own answers
|
|
403 and no token. The signed features are the plan's features verbatim, so the
|
|
engine enforces exactly what was bought, and the expiry is clamped to the
|
|
entitlement's so a token cannot outlive the subscription that paid for it.
|
|
|
|
The token is the credential the engine runs on. Treat it as a secret.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LicensingAPIPostLicensingIssueRequest
|
|
*/
|
|
func (a *LicensingAPIService) PostLicensingIssue(ctx context.Context) LicensingAPIPostLicensingIssueRequest {
|
|
return LicensingAPIPostLicensingIssueRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LicensingIssueResponse
|
|
func (a *LicensingAPIService) PostLicensingIssueExecute(r LicensingAPIPostLicensingIssueRequest) (*LicensingIssueResponse, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LicensingIssueResponse
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LicensingAPIService.PostLicensingIssue")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/licensing/issue"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.licensingIssueRequest == nil {
|
|
return localVarReturnValue, nil, reportError("licensingIssueRequest is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.licensingIssueRequest
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type LicensingAPIPostLicensingVerifyRequest struct {
|
|
ctx context.Context
|
|
ApiService *LicensingAPIService
|
|
licensingVerifyRequest *LicensingVerifyRequest
|
|
}
|
|
|
|
func (r LicensingAPIPostLicensingVerifyRequest) LicensingVerifyRequest(licensingVerifyRequest LicensingVerifyRequest) LicensingAPIPostLicensingVerifyRequest {
|
|
r.licensingVerifyRequest = &licensingVerifyRequest
|
|
return r
|
|
}
|
|
|
|
func (r LicensingAPIPostLicensingVerifyRequest) Execute() (*LicensingVerifyResponse, *http.Response, error) {
|
|
return r.ApiService.PostLicensingVerifyExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostLicensingVerify Verify checks a license token online: signature, schema, expiry, app_id and the revocation list.
|
|
|
|
Verify checks a license token online: signature, schema, expiry, app_id and
|
|
the revocation list.
|
|
|
|
It is UNAUTHENTICATED and always answers 200 — a bad token is `valid:false`
|
|
with a reason rather than an error status, because "is this token good" is a
|
|
question anyone may ask about a credential they already hold and the answer is
|
|
the same either way. It is also OPTIONAL: the engine verifies OFFLINE against
|
|
the published public key (GET /v1/licensing/pubkey) and needs this endpoint
|
|
only to learn about revocation, so an outage here never stops a paid customer
|
|
working.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return LicensingAPIPostLicensingVerifyRequest
|
|
*/
|
|
func (a *LicensingAPIService) PostLicensingVerify(ctx context.Context) LicensingAPIPostLicensingVerifyRequest {
|
|
return LicensingAPIPostLicensingVerifyRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return LicensingVerifyResponse
|
|
func (a *LicensingAPIService) PostLicensingVerifyExecute(r LicensingAPIPostLicensingVerifyRequest) (*LicensingVerifyResponse, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *LicensingVerifyResponse
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LicensingAPIService.PostLicensingVerify")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/licensing/verify"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.licensingVerifyRequest == nil {
|
|
return localVarReturnValue, nil, reportError("licensingVerifyRequest is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.licensingVerifyRequest
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|