mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
1414 lines
50 KiB
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
|
|
}
|