Files
sdk/api_link.go

1414 lines
50 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"
)
// LinkAPIService LinkAPI service
type LinkAPIService service
type LinkAPIDeleteLinkByIdRequest struct {
ctx context.Context
ApiService *LinkAPIService
id string
}
func (r LinkAPIDeleteLinkByIdRequest) Execute() (*LinkRevokeResp, *http.Response, error) {
return r.ApiService.DeleteLinkByIdExecute(r)
}
/*
DeleteLinkById Logs out one account and stops the sessions it was running.
Logs out one account and stops the sessions it was running.
It revokes a single linked account and stops the agent sessions that ran under
it, answering with the revoked row and how many sessions stopped. The link is
RETAINED with a revoked status rather than deleted, so its usage history and
the audit trail survive the log-out — which also means a revoked account still
appears in the list, and is excluded from the route plan rather than absent
from it. The session stop is narrowed to the revoking user's own sessions on
that device, provider and account, and a stop that fails does not fail the
revoke: the revoked row is the durable truth. An id that does not exist, or
belongs to another user or org, is the same 404.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the link to act on, from the path. It is scoped to the caller, so another user's or org's id is a 404.
@return LinkAPIDeleteLinkByIdRequest
*/
func (a *LinkAPIService) DeleteLinkById(ctx context.Context, id string) LinkAPIDeleteLinkByIdRequest {
return LinkAPIDeleteLinkByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return LinkRevokeResp
func (a *LinkAPIService) DeleteLinkByIdExecute(r LinkAPIDeleteLinkByIdRequest) (*LinkRevokeResp, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *LinkRevokeResp
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinkAPIService.DeleteLinkById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/link/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -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 LinkAPIGetLinkRequest struct {
ctx context.Context
ApiService *LinkAPIService
}
func (r LinkAPIGetLinkRequest) Execute() (*LinkLinkList, *http.Response, error) {
return r.ApiService.GetLinkExecute(r)
}
/*
GetLink Lists your linked accounts and the devices they sit on.
Lists your linked accounts and the devices they sit on.
It answers the caller's own links plus a devices projection of the same rows
folded per machine — the cross-machine "AI Providers / Accounts" view. A
device is a projection, not a stored entity: its labels come from its
most-recently-seen account, so there is no device to create and none to
garbage-collect. Revoked links are INCLUDED rather than dropped, because a
logged-out account keeps its usage history and audit trail. Scoped to the
caller: a validated principal and a non-empty org, else 403.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return LinkAPIGetLinkRequest
*/
func (a *LinkAPIService) GetLink(ctx context.Context) LinkAPIGetLinkRequest {
return LinkAPIGetLinkRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return LinkLinkList
func (a *LinkAPIService) GetLinkExecute(r LinkAPIGetLinkRequest) (*LinkLinkList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *LinkLinkList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinkAPIService.GetLink")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/link"
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 LinkAPIGetLinkByIdRequest struct {
ctx context.Context
ApiService *LinkAPIService
id string
}
func (r LinkAPIGetLinkByIdRequest) Execute() (*LinkLinkView, *http.Response, error) {
return r.ApiService.GetLinkByIdExecute(r)
}
/*
GetLinkById Reads one linked account.
Reads one linked account.
It answers a single link — its device, provider, account, plan, how it bills,
its status and its latest usage snapshot. An id that does not exist, or
belongs to another user or org, is the same 404: the scope is a bound
predicate on the read, so a wrong id and a foreign id are indistinguishable
and neither confirms the other's existence. The static paths on this
collection — route, usage, devices — register before this one and win
first-match, so a link whose id collided with one of those words could not be
addressed here.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the link to act on, from the path. It is scoped to the caller, so another user's or org's id is a 404.
@return LinkAPIGetLinkByIdRequest
*/
func (a *LinkAPIService) GetLinkById(ctx context.Context, id string) LinkAPIGetLinkByIdRequest {
return LinkAPIGetLinkByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return LinkLinkView
func (a *LinkAPIService) GetLinkByIdExecute(r LinkAPIGetLinkByIdRequest) (*LinkLinkView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *LinkLinkView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinkAPIService.GetLinkById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/link/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -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 LinkAPIGetLinkDevicesByMachineRequest struct {
ctx context.Context
ApiService *LinkAPIService
machine string
}
func (r LinkAPIGetLinkDevicesByMachineRequest) Execute() (*LinkDeviceView, *http.Response, error) {
return r.ApiService.GetLinkDevicesByMachineExecute(r)
}
/*
GetLinkDevicesByMachine Shows one machine: its accounts, usage and live sessions.
Shows one machine: its accounts, usage and live sessions.
It answers one device — its host and OS labels, every account the caller has
signed in on that machine with its latest usage, and how many agent sessions
the caller currently has running on it. The device labels come from the
most-recently-seen account, since a device is a projection of its links rather
than a row of its own. A machine with none of the caller's accounts is 404,
which is also the answer when the machine belongs to someone else — the scope
makes the two indistinguishable, deliberately. The session count reports 0
where the agent plane is not mounted rather than failing the read.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param machine Machine is the machine to act on, from the path. It is scoped to the caller, so a machine with none of the caller's accounts is a 404.
@return LinkAPIGetLinkDevicesByMachineRequest
*/
func (a *LinkAPIService) GetLinkDevicesByMachine(ctx context.Context, machine string) LinkAPIGetLinkDevicesByMachineRequest {
return LinkAPIGetLinkDevicesByMachineRequest{
ApiService: a,
ctx: ctx,
machine: machine,
}
}
// Execute executes the request
//
// @return LinkDeviceView
func (a *LinkAPIService) GetLinkDevicesByMachineExecute(r LinkAPIGetLinkDevicesByMachineRequest) (*LinkDeviceView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *LinkDeviceView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinkAPIService.GetLinkDevicesByMachine")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/link/devices/{machine}"
localVarPath = strings.Replace(localVarPath, "{"+"machine"+"}", url.PathEscape(parameterValueToString(r.machine, "machine")), -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 LinkAPIGetLinkRouteRequest struct {
ctx context.Context
ApiService *LinkAPIService
}
func (r LinkAPIGetLinkRouteRequest) Execute() (*LinkRoutePlan, *http.Response, error) {
return r.ApiService.GetLinkRouteExecute(r)
}
/*
GetLinkRoute Gets the failover order across your linked accounts.
Gets the failover order across your linked accounts.
It answers an ordered redundancy plan over the caller's LINKED (not revoked)
accounts: each candidate with its remaining rate-limit headroom, whether it is
routable right now, how it BILLS (plan or commerce), and a reason when it is
not — plus the primary to try first. It is what lets a router fail over from
one subscription to another and fall back to the metered API as the
always-available backstop, knowing the cost consequence before it dials.
It is POLICY, not execution: the plan is computed purely from the usage
snapshots already in the registry, never by probing a provider, so it is a
total function of the links and costs nothing to ask for. Actually dialing,
detecting a live 429 and advancing to the next candidate belongs to the
caller. A link with no snapshot counts as full headroom.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return LinkAPIGetLinkRouteRequest
*/
func (a *LinkAPIService) GetLinkRoute(ctx context.Context) LinkAPIGetLinkRouteRequest {
return LinkAPIGetLinkRouteRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return LinkRoutePlan
func (a *LinkAPIService) GetLinkRouteExecute(r LinkAPIGetLinkRouteRequest) (*LinkRoutePlan, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *LinkRoutePlan
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinkAPIService.GetLinkRoute")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/link/route"
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 LinkAPIGetLinkUsageRequest struct {
ctx context.Context
ApiService *LinkAPIService
provider *string
account *string
window *string
range_ *string
}
// Provider is the provider whose meter to read. Required.
func (r LinkAPIGetLinkUsageRequest) Provider(provider string) LinkAPIGetLinkUsageRequest {
r.provider = &provider
return r
}
// Account narrows to one account when a user has several with the provider.
func (r LinkAPIGetLinkUsageRequest) Account(account string) LinkAPIGetLinkUsageRequest {
r.account = &account
return r
}
// Window selects a window class: 6h, day, week or month. Empty reads all.
func (r LinkAPIGetLinkUsageRequest) Window(window string) LinkAPIGetLinkUsageRequest {
r.window = &window
return r
}
// Range is the period, one of 1h, 24h, 7d or 30d; empty means 24h, and an unknown label is 400, never a quiet fallback.
func (r LinkAPIGetLinkUsageRequest) Range_(range_ string) LinkAPIGetLinkUsageRequest {
r.range_ = &range_
return r
}
func (r LinkAPIGetLinkUsageRequest) Execute() (*LinkBoardResp, *http.Response, error) {
return r.ApiService.GetLinkUsageExecute(r)
}
/*
GetLinkUsage Shows one provider account's own usage dashboard.
Shows one provider account's own usage dashboard.
It answers the time series for a SINGLE provider account — the windows in
range plus the currently-open ones — as that provider's own meter reported it:
"my plan is 47% through its 6h window, resets at 14:20". current is the newest
instance of each lane (the headline); windows is the history behind it, both
computed from ONE deduped read. provider is required; an unknown window class
or range is 400, never a quiet fallback to a different one. When no series is
available the response is a 200 with available:false and empty lists — an
honest "we have no data", which is a different claim from zero usage.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return LinkAPIGetLinkUsageRequest
*/
func (a *LinkAPIService) GetLinkUsage(ctx context.Context) LinkAPIGetLinkUsageRequest {
return LinkAPIGetLinkUsageRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return LinkBoardResp
func (a *LinkAPIService) GetLinkUsageExecute(r LinkAPIGetLinkUsageRequest) (*LinkBoardResp, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *LinkBoardResp
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinkAPIService.GetLinkUsage")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/link/usage"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.provider != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "provider", r.provider, "form", "")
}
if r.account != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "account", r.account, "form", "")
}
if r.window != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "window", r.window, "form", "")
}
if r.range_ != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "range", r.range_, "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
}
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 LinkAPIGetLinkUsageAccountsRequest struct {
ctx context.Context
ApiService *LinkAPIService
}
func (r LinkAPIGetLinkUsageAccountsRequest) Execute() (*LinkAccountsUsage, *http.Response, error) {
return r.ApiService.GetLinkUsageAccountsExecute(r)
}
/*
GetLinkUsageAccounts Breaks down what the gateway routed through each of your accounts.
Breaks down what the gateway routed through each of your accounts.
It answers one row per linked account the GATEWAY actually routed through,
plus their total — requests, prompt and completion tokens, and cost. This is
the routed ledger, the read twin of the counter the router writes, and it is
distinct from both of its neighbours: not the device collector's plan
snapshots, and not the org money ledger. The source and scope fields on the
response say so on every payload. The same shape answers in the billing
namespace, from one shaping function, so the two mounts cannot drift.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return LinkAPIGetLinkUsageAccountsRequest
*/
func (a *LinkAPIService) GetLinkUsageAccounts(ctx context.Context) LinkAPIGetLinkUsageAccountsRequest {
return LinkAPIGetLinkUsageAccountsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return LinkAccountsUsage
func (a *LinkAPIService) GetLinkUsageAccountsExecute(r LinkAPIGetLinkUsageAccountsRequest) (*LinkAccountsUsage, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *LinkAccountsUsage
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinkAPIService.GetLinkUsageAccounts")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/link/usage/accounts"
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 LinkAPIGetLinkUsageSummaryRequest struct {
ctx context.Context
ApiService *LinkAPIService
range_ *string
}
// Range is the period, one of 1h, 24h, 7d or 30d; empty means 24h, and an unknown label is 400, never a silent substitution.
func (r LinkAPIGetLinkUsageSummaryRequest) Range_(range_ string) LinkAPIGetLinkUsageSummaryRequest {
r.range_ = &range_
return r
}
func (r LinkAPIGetLinkUsageSummaryRequest) Execute() (*LinkSummaryResp, *http.Response, error) {
return r.ApiService.GetLinkUsageSummaryExecute(r)
}
/*
GetLinkUsageSummary Shows plan consumption and Hanzo spend side by side.
Shows plan consumption and Hanzo spend side by side.
It answers the global usage board over one window: the caller's own linked
accounts, metered from each provider's own login, alongside their org's
Hanzo-routed inference. These come from different ledgers and mean different
things, so every row is LABELLED by source, by scope and by availability, and
THE TWO ARE NEVER SUMMED — a plan's percentage is not money, and a provider's
own spend is not a Hanzo charge. The rows sit side by side and say what they
are.
One resolver fixes the window for both halves, so the two sets always cover
the same period. range is one of 1h, 24h, 7d or 30d and defaults to 24h;
anything else is 400 rather than a silent substitution. A ledger that cannot
answer reports available:false instead of a zero that would read as "no usage".
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return LinkAPIGetLinkUsageSummaryRequest
*/
func (a *LinkAPIService) GetLinkUsageSummary(ctx context.Context) LinkAPIGetLinkUsageSummaryRequest {
return LinkAPIGetLinkUsageSummaryRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return LinkSummaryResp
func (a *LinkAPIService) GetLinkUsageSummaryExecute(r LinkAPIGetLinkUsageSummaryRequest) (*LinkSummaryResp, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *LinkSummaryResp
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinkAPIService.GetLinkUsageSummary")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/link/usage/summary"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.range_ != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "range", r.range_, "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
}
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 LinkAPIPostLinkRequest struct {
ctx context.Context
ApiService *LinkAPIService
linkEnrollReq *LinkEnrollReq
}
func (r LinkAPIPostLinkRequest) LinkEnrollReq(linkEnrollReq LinkEnrollReq) LinkAPIPostLinkRequest {
r.linkEnrollReq = &linkEnrollReq
return r
}
func (r LinkAPIPostLinkRequest) Execute() (*LinkLinkView, *http.Response, error) {
return r.ApiService.PostLinkExecute(r)
}
/*
PostLink Registers a signed-in AI provider account on a machine.
Registers a signed-in AI provider account on a machine.
It records that a developer has signed into one provider account on one
machine — a Claude Max or ChatGPT Plus subscription, a Hanzo key, a raw
provider key — and answers 201 with the stored link. Re-reporting the same
(machine, provider, account) UPDATES that link rather than creating a second,
so a collector may call this on every heartbeat. machine and provider are
required (400 otherwise), as is a valid kind, and every field is
length-bounded. Scoped to the caller: a validated principal and a non-empty
org, else 403, so a caller writes only their OWN accounts within their own org.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return LinkAPIPostLinkRequest
*/
func (a *LinkAPIService) PostLink(ctx context.Context) LinkAPIPostLinkRequest {
return LinkAPIPostLinkRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return LinkLinkView
func (a *LinkAPIService) PostLinkExecute(r LinkAPIPostLinkRequest) (*LinkLinkView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *LinkLinkView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinkAPIService.PostLink")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/link"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.linkEnrollReq == nil {
return localVarReturnValue, nil, reportError("linkEnrollReq 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.linkEnrollReq
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 LinkAPIPostLinkDevicesByMachineRevokeRequest struct {
ctx context.Context
ApiService *LinkAPIService
machine string
}
func (r LinkAPIPostLinkDevicesByMachineRevokeRequest) Execute() (*LinkRevokeResp, *http.Response, error) {
return r.ApiService.PostLinkDevicesByMachineRevokeExecute(r)
}
/*
PostLinkDevicesByMachineRevoke Logs out every account on one machine and stops its sessions.
Logs out every account on one machine and stops its sessions.
It revokes every one of the caller's accounts on one machine and stops the
agent sessions they were running, answering with how many of each. This is the
"I lost that laptop" button. Revoked links are RETAINED, not deleted, so usage
history and the audit trail survive a log-out — the rows come back in the
response with their new status. The session stop reaches only the REVOKING
user's own sessions, so a shared machine name can never be used to stop a
co-tenant's work, and a stop that fails does not fail the revoke: the revoked
row is the durable truth and the count then honestly reports fewer. A machine
with nothing left to revoke is 404.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param machine Machine is the machine to act on, from the path. It is scoped to the caller, so a machine with none of the caller's accounts is a 404.
@return LinkAPIPostLinkDevicesByMachineRevokeRequest
*/
func (a *LinkAPIService) PostLinkDevicesByMachineRevoke(ctx context.Context, machine string) LinkAPIPostLinkDevicesByMachineRevokeRequest {
return LinkAPIPostLinkDevicesByMachineRevokeRequest{
ApiService: a,
ctx: ctx,
machine: machine,
}
}
// Execute executes the request
//
// @return LinkRevokeResp
func (a *LinkAPIService) PostLinkDevicesByMachineRevokeExecute(r LinkAPIPostLinkDevicesByMachineRevokeRequest) (*LinkRevokeResp, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *LinkRevokeResp
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinkAPIService.PostLinkDevicesByMachineRevoke")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/link/devices/{machine}/revoke"
localVarPath = strings.Replace(localVarPath, "{"+"machine"+"}", url.PathEscape(parameterValueToString(r.machine, "machine")), -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 LinkAPIPostLinkUsageRequest struct {
ctx context.Context
ApiService *LinkAPIService
linkIngestReq *LinkIngestReq
}
func (r LinkAPIPostLinkUsageRequest) LinkIngestReq(linkIngestReq LinkIngestReq) LinkAPIPostLinkUsageRequest {
r.linkIngestReq = &linkIngestReq
return r
}
func (r LinkAPIPostLinkUsageRequest) Execute() (*LinkIngestResp, *http.Response, error) {
return r.ApiService.PostLinkUsageExecute(r)
}
/*
PostLinkUsage Reports usage samples from the device collector.
Reports usage samples from the device collector.
It ingests a batch of usage samples and answers with how many were accepted,
whether history was durably stored, and the links they refreshed. A report
also REFRESHES one link per distinct (machine, provider, account) it names, so
a running collector keeps the accounts overview current without a separate
registration call.
A caller can only ever report for THEMSELVES: org and subject come from the
validated bearer, never from the body, so no sample can be attributed to
another user or tenant. History is FAIL-SOFT and stored says which happened —
a warehouse outage still accepts the report and refreshes the links rather
than failing the device, and answers 202 either way. Send either one sample
inline or up to 256 in samples; an empty batch or an over-long one is 400, as
is a provider, window class or kind outside the closed vocabulary — an
unrecognized window is refused rather than rewritten, because a silently
reclassified sample would fill a dashboard with a class nobody reported.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return LinkAPIPostLinkUsageRequest
*/
func (a *LinkAPIService) PostLinkUsage(ctx context.Context) LinkAPIPostLinkUsageRequest {
return LinkAPIPostLinkUsageRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return LinkIngestResp
func (a *LinkAPIService) PostLinkUsageExecute(r LinkAPIPostLinkUsageRequest) (*LinkIngestResp, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *LinkIngestResp
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "LinkAPIService.PostLinkUsage")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/link/usage"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.linkIngestReq == nil {
return localVarReturnValue, nil, reportError("linkIngestReq 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.linkIngestReq
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
}