Files
sdk/api_iam.go

19425 lines
662 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"
)
// IamAPIService IamAPI service
type IamAPIService service
type IamAPIAddProviderRequest struct {
ctx context.Context
ApiService *IamAPIService
iamProvider *IamProvider
}
func (r IamAPIAddProviderRequest) IamProvider(iamProvider IamProvider) IamAPIAddProviderRequest {
r.iamProvider = &iamProvider
return r
}
func (r IamAPIAddProviderRequest) Execute() (*IamProviderResult, *http.Response, error) {
return r.ApiService.AddProviderExecute(r)
}
/*
AddProvider Adds an identity provider your people can sign in with, or a service your applications send through — a social or enterprise login, an email or SMS sender, a storage or payment connector.
Adds an identity provider your people can sign in with, or a
service your applications send through — a social or enterprise login, an email
or SMS sender, a storage or payment connector.
A provider is configured once and then switched on per application, so several
applications can share one set of credentials.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIAddProviderRequest
*/
func (a *IamAPIService) AddProvider(ctx context.Context) IamAPIAddProviderRequest {
return IamAPIAddProviderRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamProviderResult
func (a *IamAPIService) AddProviderExecute(r IamAPIAddProviderRequest) (*IamProviderResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamProviderResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.AddProvider")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/providers"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamProvider == nil {
return localVarReturnValue, nil, reportError("iamProvider 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.iamProvider
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 IamAPIAddTokenRequest struct {
ctx context.Context
ApiService *IamAPIService
iamToken *IamToken
}
func (r IamAPIAddTokenRequest) IamToken(iamToken IamToken) IamAPIAddTokenRequest {
r.iamToken = &iamToken
return r
}
func (r IamAPIAddTokenRequest) Execute() (*IamTokenResult, *http.Response, error) {
return r.ApiService.AddTokenExecute(r)
}
/*
AddToken Records an access token — the credential an application or integration presents on a caller's behalf.
Records an access token — the credential an application or integration
presents on a caller's behalf.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIAddTokenRequest
*/
func (a *IamAPIService) AddToken(ctx context.Context) IamAPIAddTokenRequest {
return IamAPIAddTokenRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamTokenResult
func (a *IamAPIService) AddTokenExecute(r IamAPIAddTokenRequest) (*IamTokenResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamTokenResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.AddToken")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/tokens"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamToken == nil {
return localVarReturnValue, nil, reportError("iamToken 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.iamToken
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 IamAPIAddWebauthnCredentialRequest struct {
ctx context.Context
ApiService *IamAPIService
iamWebauthnCredential *IamWebauthnCredential
}
func (r IamAPIAddWebauthnCredentialRequest) IamWebauthnCredential(iamWebauthnCredential IamWebauthnCredential) IamAPIAddWebauthnCredentialRequest {
r.iamWebauthnCredential = &iamWebauthnCredential
return r
}
func (r IamAPIAddWebauthnCredentialRequest) Execute() (*IamWebauthnCredentialResult, *http.Response, error) {
return r.ApiService.AddWebauthnCredentialExecute(r)
}
/*
AddWebauthnCredential Registers a passkey or security key for a person, so they can sign in with their device instead of a password.
Registers a passkey or security key for a person, so they
can sign in with their device instead of a password.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIAddWebauthnCredentialRequest
*/
func (a *IamAPIService) AddWebauthnCredential(ctx context.Context) IamAPIAddWebauthnCredentialRequest {
return IamAPIAddWebauthnCredentialRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamWebauthnCredentialResult
func (a *IamAPIService) AddWebauthnCredentialExecute(r IamAPIAddWebauthnCredentialRequest) (*IamWebauthnCredentialResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamWebauthnCredentialResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.AddWebauthnCredential")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/webauthn-credentials"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamWebauthnCredential == nil {
return localVarReturnValue, nil, reportError("iamWebauthnCredential 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.iamWebauthnCredential
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 IamAPICreateOrganizationRequest struct {
ctx context.Context
ApiService *IamAPIService
iamCreateOrganizationInput *IamCreateOrganizationInput
}
func (r IamAPICreateOrganizationRequest) IamCreateOrganizationInput(iamCreateOrganizationInput IamCreateOrganizationInput) IamAPICreateOrganizationRequest {
r.iamCreateOrganizationInput = &iamCreateOrganizationInput
return r
}
func (r IamAPICreateOrganizationRequest) Execute() (*IamOrganization, *http.Response, error) {
return r.ApiService.CreateOrganizationExecute(r)
}
/*
CreateOrganization Makes a new organization — the account your users, applications, roles, projects and workspaces are all named inside.
Makes a new organization — the account your users, applications, roles,
projects and workspaces are all named inside. It is the first write in a new
tenant, and a name already in use is refused rather than taken over.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPICreateOrganizationRequest
*/
func (a *IamAPIService) CreateOrganization(ctx context.Context) IamAPICreateOrganizationRequest {
return IamAPICreateOrganizationRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamOrganization
func (a *IamAPIService) CreateOrganizationExecute(r IamAPICreateOrganizationRequest) (*IamOrganization, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamOrganization
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.CreateOrganization")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/organizations"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamCreateOrganizationInput == nil {
return localVarReturnValue, nil, reportError("iamCreateOrganizationInput 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.iamCreateOrganizationInput
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 IamAPICreateSessionRequest struct {
ctx context.Context
ApiService *IamAPIService
iamCreateSessionIn *IamCreateSessionIn
}
func (r IamAPICreateSessionRequest) IamCreateSessionIn(iamCreateSessionIn IamCreateSessionIn) IamAPICreateSessionRequest {
r.iamCreateSessionIn = &iamCreateSessionIn
return r
}
func (r IamAPICreateSessionRequest) Execute() (*IamSession, *http.Response, error) {
return r.ApiService.CreateSessionExecute(r)
}
/*
CreateSession Records a sign-in and answers with the cookie id it minted.
Records a sign-in and answers with the cookie id it minted. Signing in
again from another browser adds to the session rather than replacing it, so one
person can be signed in from a laptop and a phone at once.
Ask for an exclusive sign-in and the opposite holds: the new sign-in is the only
one left and every other browser is signed out. That is the setting to use when
one person may hold only one live session at a time.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPICreateSessionRequest
*/
func (a *IamAPIService) CreateSession(ctx context.Context) IamAPICreateSessionRequest {
return IamAPICreateSessionRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamSession
func (a *IamAPIService) CreateSessionExecute(r IamAPICreateSessionRequest) (*IamSession, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamSession
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.CreateSession")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/sessions"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamCreateSessionIn == nil {
return localVarReturnValue, nil, reportError("iamCreateSessionIn 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.iamCreateSessionIn
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 IamAPIDeleteIamApplicationsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteIamApplicationsByOwnerByNameRequest) Execute() (*IamDeleteResult, *http.Response, error) {
return r.ApiService.DeleteIamApplicationsByOwnerByNameExecute(r)
}
/*
DeleteIamApplicationsByOwnerByName Removes an application.
Removes an application. Anyone mid-sign-in through it is
turned away and its client credentials stop working, so retire the integration
before deleting it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteIamApplicationsByOwnerByNameRequest
*/
func (a *IamAPIService) DeleteIamApplicationsByOwnerByName(ctx context.Context, owner string, name string) IamAPIDeleteIamApplicationsByOwnerByNameRequest {
return IamAPIDeleteIamApplicationsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamDeleteResult
func (a *IamAPIService) DeleteIamApplicationsByOwnerByNameExecute(r IamAPIDeleteIamApplicationsByOwnerByNameRequest) (*IamDeleteResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamDeleteResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamApplicationsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/applications/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteIamAuditLogsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteIamAuditLogsByOwnerByNameRequest) Execute() (*IamAuditlogsDeleteOutput, *http.Response, error) {
return r.ApiService.DeleteIamAuditLogsByOwnerByNameExecute(r)
}
/*
DeleteIamAuditLogsByOwnerByName Removes an audit entry.
Removes an audit entry. Retention policy is normally what should expire
a trail; deleting by hand leaves a gap a reviewer will notice.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteIamAuditLogsByOwnerByNameRequest
*/
func (a *IamAPIService) DeleteIamAuditLogsByOwnerByName(ctx context.Context, owner string, name string) IamAPIDeleteIamAuditLogsByOwnerByNameRequest {
return IamAPIDeleteIamAuditLogsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamAuditlogsDeleteOutput
func (a *IamAPIService) DeleteIamAuditLogsByOwnerByNameExecute(r IamAPIDeleteIamAuditLogsByOwnerByNameRequest) (*IamAuditlogsDeleteOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAuditlogsDeleteOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamAuditLogsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/audit-logs/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteIamCertsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteIamCertsByOwnerByNameRequest) Execute() (*IamCertsDeleteOutput, *http.Response, error) {
return r.ApiService.DeleteIamCertsByOwnerByNameExecute(r)
}
/*
DeleteIamCertsByOwnerByName Removes a signing certificate.
Removes a signing certificate. Tokens signed with it can no longer be
verified, so retire it only once nothing is still presenting them.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteIamCertsByOwnerByNameRequest
*/
func (a *IamAPIService) DeleteIamCertsByOwnerByName(ctx context.Context, owner string, name string) IamAPIDeleteIamCertsByOwnerByNameRequest {
return IamAPIDeleteIamCertsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamCertsDeleteOutput
func (a *IamAPIService) DeleteIamCertsByOwnerByNameExecute(r IamAPIDeleteIamCertsByOwnerByNameRequest) (*IamCertsDeleteOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamCertsDeleteOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamCertsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/certs/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteIamInvitationsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteIamInvitationsByOwnerByNameRequest) Execute() (*IamInvitationsDeleteOutput, *http.Response, error) {
return r.ApiService.DeleteIamInvitationsByOwnerByNameExecute(r)
}
/*
DeleteIamInvitationsByOwnerByName Withdraws an invitation.
Withdraws an invitation. It stops being redeemable at once; anyone who
already joined through it keeps their account.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteIamInvitationsByOwnerByNameRequest
*/
func (a *IamAPIService) DeleteIamInvitationsByOwnerByName(ctx context.Context, owner string, name string) IamAPIDeleteIamInvitationsByOwnerByNameRequest {
return IamAPIDeleteIamInvitationsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamInvitationsDeleteOutput
func (a *IamAPIService) DeleteIamInvitationsByOwnerByNameExecute(r IamAPIDeleteIamInvitationsByOwnerByNameRequest) (*IamInvitationsDeleteOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamInvitationsDeleteOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamInvitationsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/invitations/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteIamKeysByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteIamKeysByOwnerByNameRequest) Execute() (*IamKeysDeleteResponse, *http.Response, error) {
return r.ApiService.DeleteIamKeysByOwnerByNameExecute(r)
}
/*
DeleteIamKeysByOwnerByName Revokes an API key.
Revokes an API key. Anything still presenting it stops being authorized at
once, so roll the replacement out before you revoke.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteIamKeysByOwnerByNameRequest
*/
func (a *IamAPIService) DeleteIamKeysByOwnerByName(ctx context.Context, owner string, name string) IamAPIDeleteIamKeysByOwnerByNameRequest {
return IamAPIDeleteIamKeysByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamKeysDeleteResponse
func (a *IamAPIService) DeleteIamKeysByOwnerByNameExecute(r IamAPIDeleteIamKeysByOwnerByNameRequest) (*IamKeysDeleteResponse, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamKeysDeleteResponse
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamKeysByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/keys/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteIamMfaRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIDeleteIamMfaRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteIamMfaExecute(r)
}
/*
DeleteIamMfa Turns a factor off, so sign-in stops asking for it.
Turns a factor off, so sign-in stops asking for it. Naming no factor turns
off ALL of them — the reset path. People may do this for themselves; doing it for
somebody else takes an administrator, which is what makes it the way back in when a
phone is lost.
The recovery codes go with the last factor: they are the way past a challenge, so
keeping them alive for an account with nothing to challenge would leave a standing
credential behind.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIDeleteIamMfaRequest
*/
func (a *IamAPIService) DeleteIamMfa(ctx context.Context) IamAPIDeleteIamMfaRequest {
return IamAPIDeleteIamMfaRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) DeleteIamMfaExecute(r IamAPIDeleteIamMfaRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamMfa")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/mfa"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIDeleteIamPermissionsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteIamPermissionsByOwnerByNameRequest) Execute() (*IamDeleteResponse, *http.Response, error) {
return r.ApiService.DeleteIamPermissionsByOwnerByNameExecute(r)
}
/*
DeleteIamPermissionsByOwnerByName Revokes a permission.
Revokes a permission. Everyone who held access only through it loses
that access immediately; grants they hold by another route are untouched.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteIamPermissionsByOwnerByNameRequest
*/
func (a *IamAPIService) DeleteIamPermissionsByOwnerByName(ctx context.Context, owner string, name string) IamAPIDeleteIamPermissionsByOwnerByNameRequest {
return IamAPIDeleteIamPermissionsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamDeleteResponse
func (a *IamAPIService) DeleteIamPermissionsByOwnerByNameExecute(r IamAPIDeleteIamPermissionsByOwnerByNameRequest) (*IamDeleteResponse, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamDeleteResponse
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamPermissionsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/permissions/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteIamProjectsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteIamProjectsByOwnerByNameRequest) Execute() (*IamProjectsDeleteOutput, *http.Response, error) {
return r.ApiService.DeleteIamProjectsByOwnerByNameExecute(r)
}
/*
DeleteIamProjectsByOwnerByName Removes a project.
Removes a project. The people and roles in your organization are
unchanged; what goes is the scope itself, so move anything addressed by it
first.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteIamProjectsByOwnerByNameRequest
*/
func (a *IamAPIService) DeleteIamProjectsByOwnerByName(ctx context.Context, owner string, name string) IamAPIDeleteIamProjectsByOwnerByNameRequest {
return IamAPIDeleteIamProjectsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamProjectsDeleteOutput
func (a *IamAPIService) DeleteIamProjectsByOwnerByNameExecute(r IamAPIDeleteIamProjectsByOwnerByNameRequest) (*IamProjectsDeleteOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamProjectsDeleteOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamProjectsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/projects/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteIamRolesByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteIamRolesByOwnerByNameRequest) Execute() (*IamRolesDeleteOutput, *http.Response, error) {
return r.ApiService.DeleteIamRolesByOwnerByNameExecute(r)
}
/*
DeleteIamRolesByOwnerByName Removes a role.
Removes a role. Everyone in it loses the access it carried; their
accounts, and any other role they hold, are untouched.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteIamRolesByOwnerByNameRequest
*/
func (a *IamAPIService) DeleteIamRolesByOwnerByName(ctx context.Context, owner string, name string) IamAPIDeleteIamRolesByOwnerByNameRequest {
return IamAPIDeleteIamRolesByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamRolesDeleteOutput
func (a *IamAPIService) DeleteIamRolesByOwnerByNameExecute(r IamAPIDeleteIamRolesByOwnerByNameRequest) (*IamRolesDeleteOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamRolesDeleteOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamRolesByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/roles/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteIamScimV2UsersByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteIamScimV2UsersByOwnerByNameRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteIamScimV2UsersByOwnerByNameExecute(r)
}
/*
DeleteIamScimV2UsersByOwnerByName Deprovisions a person — how removing someone in your identity provider removes their access here.
Deprovisions a person — how removing someone in your identity
provider removes their access here. Their sessions stop working immediately.
Takes an administrator.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteIamScimV2UsersByOwnerByNameRequest
*/
func (a *IamAPIService) DeleteIamScimV2UsersByOwnerByName(ctx context.Context, owner string, name string) IamAPIDeleteIamScimV2UsersByOwnerByNameRequest {
return IamAPIDeleteIamScimV2UsersByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
func (a *IamAPIService) DeleteIamScimV2UsersByOwnerByNameExecute(r IamAPIDeleteIamScimV2UsersByOwnerByNameRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamScimV2UsersByOwnerByName")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/scim/v2/Users/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIDeleteIamServiceAccountsByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
name string
}
func (r IamAPIDeleteIamServiceAccountsByNameRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteIamServiceAccountsByNameExecute(r)
}
/*
DeleteIamServiceAccountsByName Serves DELETE /v1/iam/service-accounts/:name.
Serves DELETE /v1/iam/service-accounts/:name.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name
@return IamAPIDeleteIamServiceAccountsByNameRequest
*/
func (a *IamAPIService) DeleteIamServiceAccountsByName(ctx context.Context, name string) IamAPIDeleteIamServiceAccountsByNameRequest {
return IamAPIDeleteIamServiceAccountsByNameRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
func (a *IamAPIService) DeleteIamServiceAccountsByNameExecute(r IamAPIDeleteIamServiceAccountsByNameRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamServiceAccountsByName")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/service-accounts/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIDeleteIamTeamsByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
name string
}
func (r IamAPIDeleteIamTeamsByNameRequest) Execute() (*IamTeamsDeleteOutput, *http.Response, error) {
return r.ApiService.DeleteIamTeamsByNameExecute(r)
}
/*
DeleteIamTeamsByName Removes a team.
Removes a team. Everyone in it loses the access it carried; their
accounts, and any other team they are in, are untouched.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name
@return IamAPIDeleteIamTeamsByNameRequest
*/
func (a *IamAPIService) DeleteIamTeamsByName(ctx context.Context, name string) IamAPIDeleteIamTeamsByNameRequest {
return IamAPIDeleteIamTeamsByNameRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return IamTeamsDeleteOutput
func (a *IamAPIService) DeleteIamTeamsByNameExecute(r IamAPIDeleteIamTeamsByNameRequest) (*IamTeamsDeleteOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamTeamsDeleteOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamTeamsByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/teams/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteIamUsersByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteIamUsersByOwnerByNameRequest) Execute() (*IamDeleteOutput, *http.Response, error) {
return r.ApiService.DeleteIamUsersByOwnerByNameExecute(r)
}
/*
DeleteIamUsersByOwnerByName Removes a person from your organization.
Removes a person from your organization. Their sessions stop working
immediately and the account is gone rather than suspended — to keep the record
and only stop sign-in, update the user instead.
A SuperAdmin's account is removed only by a SuperAdmin.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteIamUsersByOwnerByNameRequest
*/
func (a *IamAPIService) DeleteIamUsersByOwnerByName(ctx context.Context, owner string, name string) IamAPIDeleteIamUsersByOwnerByNameRequest {
return IamAPIDeleteIamUsersByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamDeleteOutput
func (a *IamAPIService) DeleteIamUsersByOwnerByNameExecute(r IamAPIDeleteIamUsersByOwnerByNameRequest) (*IamDeleteOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamDeleteOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamUsersByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/users/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteIamUsersByOwnerByNameKeysRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteIamUsersByOwnerByNameKeysRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteIamUsersByOwnerByNameKeysExecute(r)
}
/*
DeleteIamUsersByOwnerByNameKeys Clears the target user's key of the requested TYPE (immediate revoke).
Clears the target user's key of the requested TYPE (immediate
revoke). Scoped by the same `?type` field mint takes, so revoking the browser key
leaves the server key working. A secret key's stored value is the sk- in its
schema.Key row.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteIamUsersByOwnerByNameKeysRequest
*/
func (a *IamAPIService) DeleteIamUsersByOwnerByNameKeys(ctx context.Context, owner string, name string) IamAPIDeleteIamUsersByOwnerByNameKeysRequest {
return IamAPIDeleteIamUsersByOwnerByNameKeysRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
func (a *IamAPIService) DeleteIamUsersByOwnerByNameKeysExecute(r IamAPIDeleteIamUsersByOwnerByNameKeysRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamUsersByOwnerByNameKeys")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/users/{owner}/{name}/keys"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIDeleteIamWorkspacesByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteIamWorkspacesByOwnerByNameRequest) Execute() (*IamWorkspacesDeleteOutput, *http.Response, error) {
return r.ApiService.DeleteIamWorkspacesByOwnerByNameExecute(r)
}
/*
DeleteIamWorkspacesByOwnerByName Removes a workspace.
Removes a workspace. The people and roles in your organization are
unchanged; what goes is the scope itself.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteIamWorkspacesByOwnerByNameRequest
*/
func (a *IamAPIService) DeleteIamWorkspacesByOwnerByName(ctx context.Context, owner string, name string) IamAPIDeleteIamWorkspacesByOwnerByNameRequest {
return IamAPIDeleteIamWorkspacesByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamWorkspacesDeleteOutput
func (a *IamAPIService) DeleteIamWorkspacesByOwnerByNameExecute(r IamAPIDeleteIamWorkspacesByOwnerByNameRequest) (*IamWorkspacesDeleteOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamWorkspacesDeleteOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteIamWorkspacesByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/workspaces/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteOrganizationRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteOrganizationRequest) Execute() (*IamDeleteOrganizationOutput, *http.Response, error) {
return r.ApiService.DeleteOrganizationExecute(r)
}
/*
DeleteOrganization Removes an organization and everything named inside it.
Removes an organization and everything named inside it. There is no
undo, and every session issued under it stops working.
The built-in admin organization cannot be deleted — losing it would leave the
account with no way back in.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteOrganizationRequest
*/
func (a *IamAPIService) DeleteOrganization(ctx context.Context, owner string, name string) IamAPIDeleteOrganizationRequest {
return IamAPIDeleteOrganizationRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamDeleteOrganizationOutput
func (a *IamAPIService) DeleteOrganizationExecute(r IamAPIDeleteOrganizationRequest) (*IamDeleteOrganizationOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamDeleteOrganizationOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteOrganization")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/organizations/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteProviderRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteProviderRequest) Execute() (*IamMutationResult, *http.Response, error) {
return r.ApiService.DeleteProviderExecute(r)
}
/*
DeleteProvider Removes a provider.
Removes a provider. Sign-in through it stops for every
application that used it, so give those applications another method first.
A provider that is already gone answers "nothing changed" rather than an
error, so the call is safe to repeat.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteProviderRequest
*/
func (a *IamAPIService) DeleteProvider(ctx context.Context, owner string, name string) IamAPIDeleteProviderRequest {
return IamAPIDeleteProviderRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamMutationResult
func (a *IamAPIService) DeleteProviderExecute(r IamAPIDeleteProviderRequest) (*IamMutationResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamMutationResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteProvider")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/providers/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteSessionRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
application string
}
func (r IamAPIDeleteSessionRequest) Execute() (*IamDeleteSessionOut, *http.Response, error) {
return r.ApiService.DeleteSessionExecute(r)
}
/*
DeleteSession Signs a person out of one application — the session ends and every browser carrying it stops being authenticated.
Signs a person out of one application — the session ends and every
browser carrying it stops being authenticated.
A session that is already gone reports that nothing was deleted rather than an
error, so the call is safe to repeat.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@param application
@return IamAPIDeleteSessionRequest
*/
func (a *IamAPIService) DeleteSession(ctx context.Context, owner string, name string, application string) IamAPIDeleteSessionRequest {
return IamAPIDeleteSessionRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
application: application,
}
}
// Execute executes the request
//
// @return IamDeleteSessionOut
func (a *IamAPIService) DeleteSessionExecute(r IamAPIDeleteSessionRequest) (*IamDeleteSessionOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamDeleteSessionOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteSession")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/sessions/{owner}/{name}/{application}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", url.PathEscape(parameterValueToString(r.application, "application")), -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 IamAPIDeleteTokenRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteTokenRequest) Execute() (*IamTokenMutation, *http.Response, error) {
return r.ApiService.DeleteTokenExecute(r)
}
/*
DeleteToken Revokes an access token.
Revokes an access token. Whatever was using it stops being
authorized at once.
A token that is already gone answers "nothing changed" rather than an error, so
the call is safe to repeat.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteTokenRequest
*/
func (a *IamAPIService) DeleteToken(ctx context.Context, owner string, name string) IamAPIDeleteTokenRequest {
return IamAPIDeleteTokenRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamTokenMutation
func (a *IamAPIService) DeleteTokenExecute(r IamAPIDeleteTokenRequest) (*IamTokenMutation, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamTokenMutation
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteToken")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/tokens/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIDeleteWebauthnCredentialRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIDeleteWebauthnCredentialRequest) Execute() (*IamWebauthnCredentialMutationResult, *http.Response, error) {
return r.ApiService.DeleteWebauthnCredentialExecute(r)
}
/*
DeleteWebauthnCredential Removes a passkey or security key — what you call when a device is lost.
Removes a passkey or security key — what you call when
a device is lost. Make sure the person has another way to sign in first.
A credential that is already gone answers "nothing changed" rather than an
error, so the call is safe to repeat.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIDeleteWebauthnCredentialRequest
*/
func (a *IamAPIService) DeleteWebauthnCredential(ctx context.Context, owner string, name string) IamAPIDeleteWebauthnCredentialRequest {
return IamAPIDeleteWebauthnCredentialRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamWebauthnCredentialMutationResult
func (a *IamAPIService) DeleteWebauthnCredentialExecute(r IamAPIDeleteWebauthnCredentialRequest) (*IamWebauthnCredentialMutationResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamWebauthnCredentialMutationResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.DeleteWebauthnCredential")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/webauthn-credentials/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetIamAccountRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamAccountRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamAccountExecute(r)
}
/*
GetIamAccount Returns the signed-in person's own account and the organization they belong to — what a console reads to draw the account menu.
Returns the signed-in person's own account and the organization
they belong to — what a console reads to draw the account menu.
Passwords, API secrets and MFA material are stripped. It answers for a session
cookie or a bearer token alike.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamAccountRequest
*/
func (a *IamAPIService) GetIamAccount(ctx context.Context) IamAPIGetIamAccountRequest {
return IamAPIGetIamAccountRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamAccountExecute(r IamAPIGetIamAccountRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamAccount")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/account"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamAccountsRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamAccountsRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamAccountsExecute(r)
}
/*
GetIamAccounts Returns the people signed in on this browser, the most recent sign-in first — what the sign-in page lists when an application asks the person to choose an account.
Returns the people signed in on this browser, the most recent
sign-in first — what the sign-in page lists when an application asks the person
to choose an account.
It reads the session cookie and nothing else, so it only ever answers the
browser holding the sessions. An account forbidden or deleted since it signed
in is left out. A browser with nobody signed in gets an empty list.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamAccountsRequest
*/
func (a *IamAPIService) GetIamAccounts(ctx context.Context) IamAPIGetIamAccountsRequest {
return IamAPIGetIamAccountsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamAccountsExecute(r IamAPIGetIamAccountsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamAccounts")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamApplicationsRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
}
func (r IamAPIGetIamApplicationsRequest) Owner(owner string) IamAPIGetIamApplicationsRequest {
r.owner = &owner
return r
}
func (r IamAPIGetIamApplicationsRequest) Execute() (*IamApplicationListResult, *http.Response, error) {
return r.ApiService.GetIamApplicationsExecute(r)
}
/*
GetIamApplications Returns the applications in one organization, newest first — each product or site your people sign in to, with the sign-in methods and redirect URIs it allows.
Returns the applications in one organization, newest first —
each product or site your people sign in to, with the sign-in methods and
redirect URIs it allows.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamApplicationsRequest
*/
func (a *IamAPIService) GetIamApplications(ctx context.Context) IamAPIGetIamApplicationsRequest {
return IamAPIGetIamApplicationsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamApplicationListResult
func (a *IamAPIService) GetIamApplicationsExecute(r IamAPIGetIamApplicationsRequest) (*IamApplicationListResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamApplicationListResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamApplications")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/applications"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner == nil {
return localVarReturnValue, nil, reportError("owner is required and must be specified")
}
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "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 IamAPIGetIamApplicationsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetIamApplicationsByOwnerByNameRequest) Execute() (*IamApplication, *http.Response, error) {
return r.ApiService.GetIamApplicationsByOwnerByNameExecute(r)
}
/*
GetIamApplicationsByOwnerByName Returns one application: its sign-in methods, its allowed redirect URIs and the client credentials your integration authenticates with.
Returns one application: its sign-in methods, its allowed
redirect URIs and the client credentials your integration authenticates with.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetIamApplicationsByOwnerByNameRequest
*/
func (a *IamAPIService) GetIamApplicationsByOwnerByName(ctx context.Context, owner string, name string) IamAPIGetIamApplicationsByOwnerByNameRequest {
return IamAPIGetIamApplicationsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamApplication
func (a *IamAPIService) GetIamApplicationsByOwnerByNameExecute(r IamAPIGetIamApplicationsByOwnerByNameRequest) (*IamApplication, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamApplication
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamApplicationsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/applications/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetIamAuditLogsRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
}
func (r IamAPIGetIamAuditLogsRequest) Owner(owner string) IamAPIGetIamAuditLogsRequest {
r.owner = &owner
return r
}
func (r IamAPIGetIamAuditLogsRequest) Execute() (*IamAuditlogsListOutput, *http.Response, error) {
return r.ApiService.GetIamAuditLogsExecute(r)
}
/*
GetIamAuditLogs Returns your organization's audit trail, newest first — who did what, when, and from where.
Returns your organization's audit trail, newest first — who did
what, when, and from where. It is the record you reach for during a security
review or an incident.
You see your own organization's audit trail and no one else's; which organization that
is comes from your credentials, not from the request.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamAuditLogsRequest
*/
func (a *IamAPIService) GetIamAuditLogs(ctx context.Context) IamAPIGetIamAuditLogsRequest {
return IamAPIGetIamAuditLogsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamAuditlogsListOutput
func (a *IamAPIService) GetIamAuditLogsExecute(r IamAPIGetIamAuditLogsRequest) (*IamAuditlogsListOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAuditlogsListOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamAuditLogs")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/audit-logs"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "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 IamAPIGetIamAuditLogsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetIamAuditLogsByOwnerByNameRequest) Execute() (*IamAuditLog, *http.Response, error) {
return r.ApiService.GetIamAuditLogsByOwnerByNameExecute(r)
}
/*
GetIamAuditLogsByOwnerByName Returns one audit entry in full: the action, the person or key behind it, and the request it came in on.
Returns one audit entry in full: the action, the person or key behind it,
and the request it came in on.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetIamAuditLogsByOwnerByNameRequest
*/
func (a *IamAPIService) GetIamAuditLogsByOwnerByName(ctx context.Context, owner string, name string) IamAPIGetIamAuditLogsByOwnerByNameRequest {
return IamAPIGetIamAuditLogsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamAuditLog
func (a *IamAPIService) GetIamAuditLogsByOwnerByNameExecute(r IamAPIGetIamAuditLogsByOwnerByNameRequest) (*IamAuditLog, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAuditLog
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamAuditLogsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/audit-logs/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetIamAuthApplicationRequest struct {
ctx context.Context
ApiService *IamAPIService
clientId *string
responseType *string
}
// ClientId is the application's OAuth client id — the one field that selects which login screen this is.
func (r IamAPIGetIamAuthApplicationRequest) ClientId(clientId string) IamAPIGetIamAuthApplicationRequest {
r.clientId = &clientId
return r
}
// ResponseType is the OAuth response type the screen will ask for. Only \"code\" is served; anything else is refused here rather than at the authorize leg, where the person has already typed a password.
func (r IamAPIGetIamAuthApplicationRequest) ResponseType(responseType string) IamAPIGetIamAuthApplicationRequest {
r.responseType = &responseType
return r
}
func (r IamAPIGetIamAuthApplicationRequest) Execute() (*IamAnswer, *http.Response, error) {
return r.ApiService.GetIamAuthApplicationExecute(r)
}
/*
GetIamAuthApplication Returns everything a login screen needs to draw itself for one application: its branding, and each sign-in method it offers with the provider details that method needs.
Returns everything a login screen needs to draw itself for one
application: its branding, and each sign-in method it offers with the provider
details that method needs.
The client secret is masked. Read before anyone has signed in, so it carries
only what is safe for a browser to see.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamAuthApplicationRequest
*/
func (a *IamAPIService) GetIamAuthApplication(ctx context.Context) IamAPIGetIamAuthApplicationRequest {
return IamAPIGetIamAuthApplicationRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamAnswer
func (a *IamAPIService) GetIamAuthApplicationExecute(r IamAPIGetIamAuthApplicationRequest) (*IamAnswer, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAnswer
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamAuthApplication")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/auth/application"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.clientId != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "clientId", r.clientId, "form", "")
}
if r.responseType != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "responseType", r.responseType, "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,
}
if localVarHTTPResponse.StatusCode == 400 {
var v IamAnswer
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
}
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 IamAPIGetIamAuthMethodsRequest struct {
ctx context.Context
ApiService *IamAPIService
clientId *string
}
// ClientId is the application's OAuth client id.
func (r IamAPIGetIamAuthMethodsRequest) ClientId(clientId string) IamAPIGetIamAuthMethodsRequest {
r.clientId = &clientId
return r
}
func (r IamAPIGetIamAuthMethodsRequest) Execute() (*IamAnswer, *http.Response, error) {
return r.ApiService.GetIamAuthMethodsExecute(r)
}
/*
GetIamAuthMethods Returns the sign-in methods one application actually has switched on, so a login screen can render the right buttons for it without you hard-coding a list that drifts the moment you add a provider.
Returns the sign-in methods one application actually has switched
on, so a login screen can render the right buttons for it without you
hard-coding a list that drifts the moment you add a provider.
Public by design: it is read before anyone has signed in, and it exposes only
which methods exist, never their credentials.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamAuthMethodsRequest
*/
func (a *IamAPIService) GetIamAuthMethods(ctx context.Context) IamAPIGetIamAuthMethodsRequest {
return IamAPIGetIamAuthMethodsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamAnswer
func (a *IamAPIService) GetIamAuthMethodsExecute(r IamAPIGetIamAuthMethodsRequest) (*IamAnswer, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAnswer
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamAuthMethods")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/auth/methods"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.clientId != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "clientId", r.clientId, "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,
}
if localVarHTTPResponse.StatusCode == 400 {
var v IamAnswer
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
}
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 IamAPIGetIamCertsRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
}
func (r IamAPIGetIamCertsRequest) Owner(owner string) IamAPIGetIamCertsRequest {
r.owner = &owner
return r
}
func (r IamAPIGetIamCertsRequest) Execute() (*IamCertsListOutput, *http.Response, error) {
return r.ApiService.GetIamCertsExecute(r)
}
/*
GetIamCerts Returns your organization's signing certificates, newest first — the keys the tokens your applications verify are signed with.
Returns your organization's signing certificates, newest first — the keys
the tokens your applications verify are signed with. Private key material is
masked.
You see your own organization's certificates and no one else's; which
organization that is comes from your credentials, not from the request, so a
query parameter can never widen the listing.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamCertsRequest
*/
func (a *IamAPIService) GetIamCerts(ctx context.Context) IamAPIGetIamCertsRequest {
return IamAPIGetIamCertsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamCertsListOutput
func (a *IamAPIService) GetIamCertsExecute(r IamAPIGetIamCertsRequest) (*IamCertsListOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamCertsListOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamCerts")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/certs"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "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 IamAPIGetIamCertsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetIamCertsByOwnerByNameRequest) Execute() (*IamCert, *http.Response, error) {
return r.ApiService.GetIamCertsByOwnerByNameExecute(r)
}
/*
GetIamCertsByOwnerByName Returns one signing certificate — its algorithm, its validity window and its public half.
Returns one signing certificate — its algorithm, its validity window and
its public half. The private key is masked.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetIamCertsByOwnerByNameRequest
*/
func (a *IamAPIService) GetIamCertsByOwnerByName(ctx context.Context, owner string, name string) IamAPIGetIamCertsByOwnerByNameRequest {
return IamAPIGetIamCertsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamCert
func (a *IamAPIService) GetIamCertsByOwnerByNameExecute(r IamAPIGetIamCertsByOwnerByNameRequest) (*IamCert, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamCert
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamCertsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/certs/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetIamConsentRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamConsentRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamConsentExecute(r)
}
/*
GetIamConsent Returns the calling person's own privacy and communication choices.
Returns the calling person's own privacy and communication
choices. Somebody who has never set them gets the defaults rather than
nothing, so a consent screen always has something to show — insights on, and
training UNANSWERED, which is the state that means the screen still has to ask.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamConsentRequest
*/
func (a *IamAPIService) GetIamConsent(ctx context.Context) IamAPIGetIamConsentRequest {
return IamAPIGetIamConsentRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamConsentExecute(r IamAPIGetIamConsentRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamConsent")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/consent"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamInvitationsRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
}
func (r IamAPIGetIamInvitationsRequest) Owner(owner string) IamAPIGetIamInvitationsRequest {
r.owner = &owner
return r
}
func (r IamAPIGetIamInvitationsRequest) Execute() (*IamInvitationsListOutput, *http.Response, error) {
return r.ApiService.GetIamInvitationsExecute(r)
}
/*
GetIamInvitations Returns your organization's invitations, newest first — who has been asked to join, on what terms, and how many seats each invitation still has left.
Returns your organization's invitations, newest first — who has
been asked to join, on what terms, and how many seats each invitation still
has left.
You see the invitations of the organization your credentials run, and no one
else's: your own, or one you own or administer.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamInvitationsRequest
*/
func (a *IamAPIService) GetIamInvitations(ctx context.Context) IamAPIGetIamInvitationsRequest {
return IamAPIGetIamInvitationsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamInvitationsListOutput
func (a *IamAPIService) GetIamInvitationsExecute(r IamAPIGetIamInvitationsRequest) (*IamInvitationsListOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamInvitationsListOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamInvitations")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/invitations"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "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 IamAPIGetIamInvitationsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetIamInvitationsByOwnerByNameRequest) Execute() (*IamInvitation, *http.Response, error) {
return r.ApiService.GetIamInvitationsByOwnerByNameExecute(r)
}
/*
GetIamInvitationsByOwnerByName Returns one invitation: who it is for, what it grants on acceptance, and when it expires.
Returns one invitation: who it is for, what it grants on acceptance, and
when it expires.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetIamInvitationsByOwnerByNameRequest
*/
func (a *IamAPIService) GetIamInvitationsByOwnerByName(ctx context.Context, owner string, name string) IamAPIGetIamInvitationsByOwnerByNameRequest {
return IamAPIGetIamInvitationsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamInvitation
func (a *IamAPIService) GetIamInvitationsByOwnerByNameExecute(r IamAPIGetIamInvitationsByOwnerByNameRequest) (*IamInvitation, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamInvitation
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamInvitationsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/invitations/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetIamKeysRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
}
func (r IamAPIGetIamKeysRequest) Owner(owner string) IamAPIGetIamKeysRequest {
r.owner = &owner
return r
}
func (r IamAPIGetIamKeysRequest) Execute() (*IamKeysListResponse, *http.Response, error) {
return r.ApiService.GetIamKeysExecute(r)
}
/*
GetIamKeys Returns the API keys of an organization that you may see, newest first — what each is called, what it may reach, its publishable half, and when it was last used.
Returns the API keys of an organization that you may see, newest first —
what each is called, what it may reach, its publishable half, and when it was
last used. Secret halves are never listed.
Which keys come from your credentials, not from the request. You may name an
organization you belong to: its admin sees every key it holds, and a member sees
the keys they hold there. Naming any other organization is refused.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamKeysRequest
*/
func (a *IamAPIService) GetIamKeys(ctx context.Context) IamAPIGetIamKeysRequest {
return IamAPIGetIamKeysRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamKeysListResponse
func (a *IamAPIService) GetIamKeysExecute(r IamAPIGetIamKeysRequest) (*IamKeysListResponse, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamKeysListResponse
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamKeys")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/keys"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "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 IamAPIGetIamKeysByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetIamKeysByOwnerByNameRequest) Execute() (*IamKey, *http.Response, error) {
return r.ApiService.GetIamKeysByOwnerByNameExecute(r)
}
/*
GetIamKeysByOwnerByName Returns one API key: what it is called, what it may reach, and when it was issued.
Returns one API key: what it is called, what it may reach, and when it was
issued.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetIamKeysByOwnerByNameRequest
*/
func (a *IamAPIService) GetIamKeysByOwnerByName(ctx context.Context, owner string, name string) IamAPIGetIamKeysByOwnerByNameRequest {
return IamAPIGetIamKeysByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamKey
func (a *IamAPIService) GetIamKeysByOwnerByNameExecute(r IamAPIGetIamKeysByOwnerByNameRequest) (*IamKey, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamKey
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamKeysByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/keys/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetIamKeysOrgRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamKeysOrgRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamKeysOrgExecute(r)
}
/*
GetIamKeysOrg Resolve a PUBLISHABLE key to the organization that owns it
Answers which organization a publishable key belongs to — what a service calls to attribute a request that arrived carrying a key shipped in a browser. This is the noun spelling of `/v1/iam/resolve-key`, the same handler at the address that replaces it; both answer while callers migrate.
It names an ORGANIZATION and never a person. No path through it loads or returns a user, so a key placed in client code cannot become a way to learn who anyone is — which is the whole reason this is a separate endpoint from the one below.
A key that is expired, secret rather than publishable, or simply unknown all answer with the same sentence and a `code` saying which it was. Only a confidential service that has already proved it may resolve keys reads that code — there is no anonymous caller here to probe which keys exist — and telling those apart is what lets a holder be told to re-mint an expired key instead of hunting a configuration error.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamKeysOrgRequest
*/
func (a *IamAPIService) GetIamKeysOrg(ctx context.Context) IamAPIGetIamKeysOrgRequest {
return IamAPIGetIamKeysOrgRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamKeysOrgExecute(r IamAPIGetIamKeysOrgRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamKeysOrg")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/keys/org"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamKeysPrincipalRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamKeysPrincipalRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamKeysPrincipalExecute(r)
}
/*
GetIamKeysPrincipal Resolve a SECRET key to the principal it authenticates
Answers who a secret key belongs to — the owner and name a gateway needs to attribute and bill a request that arrived carrying an `sk-`. This is the noun spelling of `/v1/iam/get-user?accessKey=`, the same handler at the address that replaces it; both answer while callers migrate.
It resolves a KEY and nothing else. The verb it replaces also reads a user by `?id=`, and carrying that here would make this a second address for the user read — the exact thing being retired. Ask for a person by name at the user read; ask here only what a credential resolves to.
Requires a confidential caller: the resolver authenticates as an app, so a request without that credential resolves nothing rather than falling back to an anonymous lookup. An unresolvable key answers with a `code` distinguishing expired from wrong-endpoint from unknown, so the holder can be told which one cure applies.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamKeysPrincipalRequest
*/
func (a *IamAPIService) GetIamKeysPrincipal(ctx context.Context) IamAPIGetIamKeysPrincipalRequest {
return IamAPIGetIamKeysPrincipalRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamKeysPrincipalExecute(r IamAPIGetIamKeysPrincipalRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamKeysPrincipal")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/keys/principal"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamLinkRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamLinkRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamLinkExecute(r)
}
/*
GetIamLink Continues a link in the browser of the person it is for: the browser opens the address POST /v1/iam/link answered, as a top-level navigation, signed in here as that person, and is sent on to the provider.
Continues a link in the browser of the person it is for: the browser
opens the address POST /v1/iam/link answered, as a top-level navigation, signed
in here as that person, and is sent on to the provider.
The address works once. The provider leg runs on a fresh transaction, bound to
this browser by a cookie set on this navigation, so that transaction and its
binding exist only here.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamLinkRequest
*/
func (a *IamAPIService) GetIamLink(ctx context.Context) IamAPIGetIamLinkRequest {
return IamAPIGetIamLinkRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamLinkExecute(r IamAPIGetIamLinkRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamLink")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamLinkedAccountsRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamLinkedAccountsRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamLinkedAccountsExecute(r)
}
/*
GetIamLinkedAccounts Returns the sign-in identities linked to the calling person's account — every provider they can currently sign in with.
Returns the sign-in identities linked to the calling
person's account — every provider they can currently sign in with. It is what
a security page lists next to the option to disconnect one.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamLinkedAccountsRequest
*/
func (a *IamAPIService) GetIamLinkedAccounts(ctx context.Context) IamAPIGetIamLinkedAccountsRequest {
return IamAPIGetIamLinkedAccountsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamLinkedAccountsExecute(r IamAPIGetIamLinkedAccountsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamLinkedAccounts")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/linked-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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamMembershipsRequest struct {
ctx context.Context
ApiService *IamAPIService
user *string
org *string
}
// User is \"<homeOrg>/<username>\" — which organizations that identity may act in.
func (r IamAPIGetIamMembershipsRequest) User(user string) IamAPIGetIamMembershipsRequest {
r.user = &user
return r
}
// Org is an organization — who may act in it.
func (r IamAPIGetIamMembershipsRequest) Org(org string) IamAPIGetIamMembershipsRequest {
r.org = &org
return r
}
func (r IamAPIGetIamMembershipsRequest) Execute() (*IamAnswer, *http.Response, error) {
return r.ApiService.GetIamMembershipsExecute(r)
}
/*
GetIamMemberships Answers either question about who belongs where: which organizations one person can act in, or who can act in one organization.
Answers either question about who belongs where: which organizations one
person can act in, or who can act in one organization.
Both are org-scoped: a non-SuperAdmin may read the roster of an org it belongs
to, or the tenancy of a person whose account it administers, and nothing else.
The bound comes from the verified credential via principal.ScopeRead, so a
request parameter can never widen it — a membership row names who may act and
spend in an org, so a roster read by a stranger is a customer roster leak.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamMembershipsRequest
*/
func (a *IamAPIService) GetIamMemberships(ctx context.Context) IamAPIGetIamMembershipsRequest {
return IamAPIGetIamMembershipsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamAnswer
func (a *IamAPIService) GetIamMembershipsExecute(r IamAPIGetIamMembershipsRequest) (*IamAnswer, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAnswer
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamMemberships")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/memberships"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.user != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "user", r.user, "form", "")
}
if r.org != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "org", r.org, "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,
}
if localVarHTTPResponse.StatusCode == 400 {
var v IamAnswer
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
}
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 IamAPIGetIamOauthAuthorizeRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamOauthAuthorizeRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamOauthAuthorizeExecute(r)
}
/*
GetIamOauthAuthorize Starts a sign-in — the address you send a browser to, and the beginning of every OAuth and OpenID Connect flow.
Starts a sign-in — the address you send a browser to, and the
beginning of every OAuth and OpenID Connect flow.
If the person is ALREADY signed in here, it does not ask them again: it
returns them to the application with a one-time code and they never see this
page. Otherwise it shows the right way to sign in for the application they are
signing in to, or hands off to another identity provider if that is what they
pick.
A client can say what it wants with `prompt`: `none` means answer without any
screen at all — with the code if a session exists, with an error if not, but
never with a page; `login` means ask for the password again even if a session
exists; `select_account` means let the person choose among the accounts signed
in on this browser, or sign in to another. `login_hint` names which of those
accounts the request is for.
It returns only to an address the application has registered. That check
happens before anything else, so a request naming an unregistered address is
refused where the person can see it rather than being bounced onwards.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamOauthAuthorizeRequest
*/
func (a *IamAPIService) GetIamOauthAuthorize(ctx context.Context) IamAPIGetIamOauthAuthorizeRequest {
return IamAPIGetIamOauthAuthorizeRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamOauthAuthorizeExecute(r IamAPIGetIamOauthAuthorizeRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamOauthAuthorize")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/authorize"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamOauthCallbackRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamOauthCallbackRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamOauthCallbackExecute(r)
}
/*
GetIamOauthCallback Completes the round-trip: it resolves and burns the single-use transaction (checking expiry + browser binding), exchanges and verifies the IdP response, links or provisions the local user, and mints the iam authorization code the relying party expects — then redirects to the original redirect_uri with code + state.
Completes the round-trip: it resolves and burns the
single-use transaction (checking expiry + browser binding), exchanges and
verifies the IdP response, links or provisions the local user, and mints the
iam authorization code the relying party expects — then redirects to the
original redirect_uri with code + state. A redirect provider's reply is read
from the query of its GET. A form_post provider's POST is answered with a 303
to a GET of this address naming a single-use handoff that holds the reply, and
that GET finishes the sign-in.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamOauthCallbackRequest
*/
func (a *IamAPIService) GetIamOauthCallback(ctx context.Context) IamAPIGetIamOauthCallbackRequest {
return IamAPIGetIamOauthCallbackRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamOauthCallbackExecute(r IamAPIGetIamOauthCallbackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamOauthCallback")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/callback"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamOauthDelegationKeysRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamOauthDelegationKeysRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamOauthDelegationKeysExecute(r)
}
/*
GetIamOauthDelegationKeys Serves the public half of every delegation key, as a JWKS, to a confidential client allowed to delegate — the one resource server that verifies what it is handed, reading with the credential it delegates with.
Serves the public half of every delegation key, as a
JWKS, to a confidential client allowed to delegate — the one resource server
that verifies what it is handed, reading with the credential it delegates with.
To anyone else it answers as the token endpoint does: who are you, or not you.
The key is not a secret; publishing it is the hazard. A verifier that fetches
the public JWKS and trusts what verifies would admit a delegated token as the
person. So it is not in that document, and this one is not an address a relying
party is ever pointed at.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamOauthDelegationKeysRequest
*/
func (a *IamAPIService) GetIamOauthDelegationKeys(ctx context.Context) IamAPIGetIamOauthDelegationKeysRequest {
return IamAPIGetIamOauthDelegationKeysRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamOauthDelegationKeysExecute(r IamAPIGetIamOauthDelegationKeysRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamOauthDelegationKeys")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/delegation/keys"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamOauthLogoutRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamOauthLogoutRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamOauthLogoutExecute(r)
}
/*
GetIamOauthLogout Ends a sign-in and sends the browser somewhere sensible.
Ends a sign-in and sends the browser somewhere sensible. Accepts
GET or POST, so it works as a plain link.
It ACTUALLY signs you out — worth stating, because a logout that computes a
redirect and answers {"status":"ok"} while ending no session and revoking no
token is worse than none: the person on the shared machine believes it worked.
Three things happen here, in this order:
1. The browser session dies — sid revoked server-side AND the cookie expired
(sessions.Clear). Server-side revocation is the load-bearing half: a copy
of the cookie taken before logout must not still resolve.
2. The relying party's tokens are revoked when an id_token_hint names it, so
the refresh token cannot mint a fresh access token after the human left.
Revocation state is authoritative — a JWT's `exp` still reads valid for
days, so expiry is necessary but never sufficient.
3. Only then is a redirect considered, and only to a REGISTERED uri.
The open-redirect guard: a redirect happens only when a VERIFIED
id_token_hint (or client_id) identifies the application and that application
has registered the target. Nobody can turn your logout link into a redirect to
a site of their choosing.
A GET is the end-session navigation (OIDC RP-Initiated Logout 1.0 §2), so it
always ends on a page: the registered address when one was asked for, else
this issuer's sign-in page for the application being signed out of. A relying
party therefore needs no configuration to sign someone out. A POST is also how
a program signs out, so it keeps the JSON answer unless it asks for HTML.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamOauthLogoutRequest
*/
func (a *IamAPIService) GetIamOauthLogout(ctx context.Context) IamAPIGetIamOauthLogoutRequest {
return IamAPIGetIamOauthLogoutRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamOauthLogoutExecute(r IamAPIGetIamOauthLogoutRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamOauthLogout")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/logout"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamOauthUserinfoRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamOauthUserinfoRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamOauthUserinfoExecute(r)
}
/*
GetIamOauthUserinfo Returns the profile claims for whoever the access token belongs to — the standard OpenID Connect way to find out who is calling you without your application storing anything itself.
Returns the profile claims for whoever the access token
belongs to — the standard OpenID Connect way to find out who is calling you
without your application storing anything itself.
The token must still be live: revoke it and this stops answering.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamOauthUserinfoRequest
*/
func (a *IamAPIService) GetIamOauthUserinfo(ctx context.Context) IamAPIGetIamOauthUserinfoRequest {
return IamAPIGetIamOauthUserinfoRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamOauthUserinfoExecute(r IamAPIGetIamOauthUserinfoRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamOauthUserinfo")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/userinfo"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamPermissionsRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
}
func (r IamAPIGetIamPermissionsRequest) Owner(owner string) IamAPIGetIamPermissionsRequest {
r.owner = &owner
return r
}
func (r IamAPIGetIamPermissionsRequest) Execute() (*IamListResponse, *http.Response, error) {
return r.ApiService.GetIamPermissionsExecute(r)
}
/*
GetIamPermissions Returns the permissions in one organization, newest first — each one a grant saying which people or roles may do what, and to which resources.
Returns the permissions in one organization, newest first — each one a
grant saying which people or roles may do what, and to which resources.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamPermissionsRequest
*/
func (a *IamAPIService) GetIamPermissions(ctx context.Context) IamAPIGetIamPermissionsRequest {
return IamAPIGetIamPermissionsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamListResponse
func (a *IamAPIService) GetIamPermissionsExecute(r IamAPIGetIamPermissionsRequest) (*IamListResponse, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamListResponse
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamPermissions")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/permissions"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "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 IamAPIGetIamPermissionsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetIamPermissionsByOwnerByNameRequest) Execute() (*IamPermission, *http.Response, error) {
return r.ApiService.GetIamPermissionsByOwnerByNameExecute(r)
}
/*
GetIamPermissionsByOwnerByName Returns one permission: who it grants to, what it allows, and the resources it covers.
Returns one permission: who it grants to, what it allows, and the
resources it covers.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetIamPermissionsByOwnerByNameRequest
*/
func (a *IamAPIService) GetIamPermissionsByOwnerByName(ctx context.Context, owner string, name string) IamAPIGetIamPermissionsByOwnerByNameRequest {
return IamAPIGetIamPermissionsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamPermission
func (a *IamAPIService) GetIamPermissionsByOwnerByNameExecute(r IamAPIGetIamPermissionsByOwnerByNameRequest) (*IamPermission, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamPermission
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamPermissionsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/permissions/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetIamProjectsRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
}
func (r IamAPIGetIamProjectsRequest) Owner(owner string) IamAPIGetIamProjectsRequest {
r.owner = &owner
return r
}
func (r IamAPIGetIamProjectsRequest) Execute() (*IamProjectsListOutput, *http.Response, error) {
return r.ApiService.GetIamProjectsExecute(r)
}
/*
GetIamProjects Returns your organization's projects, newest first — the scope people pick between when their work is separated by product or client rather than by team.
Returns your organization's projects, newest first — the scope
people pick between when their work is separated by product or client rather
than by team.
You see your own organization's projects and no one else's; which organization that
is comes from your credentials, not from the request.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamProjectsRequest
*/
func (a *IamAPIService) GetIamProjects(ctx context.Context) IamAPIGetIamProjectsRequest {
return IamAPIGetIamProjectsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamProjectsListOutput
func (a *IamAPIService) GetIamProjectsExecute(r IamAPIGetIamProjectsRequest) (*IamProjectsListOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamProjectsListOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamProjects")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/projects"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "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 IamAPIGetIamProjectsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetIamProjectsByOwnerByNameRequest) Execute() (*IamProject, *http.Response, error) {
return r.ApiService.GetIamProjectsByOwnerByNameExecute(r)
}
/*
GetIamProjectsByOwnerByName Returns one project: what it is called and how it is set up.
Returns one project: what it is called and how it is set up.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetIamProjectsByOwnerByNameRequest
*/
func (a *IamAPIService) GetIamProjectsByOwnerByName(ctx context.Context, owner string, name string) IamAPIGetIamProjectsByOwnerByNameRequest {
return IamAPIGetIamProjectsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamProject
func (a *IamAPIService) GetIamProjectsByOwnerByNameExecute(r IamAPIGetIamProjectsByOwnerByNameRequest) (*IamProject, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamProject
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamProjectsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/projects/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetIamRegistryJwksRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamRegistryJwksRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamRegistryJwksExecute(r)
}
/*
GetIamRegistryJwks Publishes the public key your registry uses to verify the tokens issued above — the one URL to configure so the registry trusts logins without holding any secret of its own.
Publishes the public key your registry uses to verify the tokens issued
above — the one URL to configure so the registry trusts logins without holding
any secret of its own.
If no signing key is available it refuses rather than publishing an empty set,
because a registry that trusts nothing looks identical to one that trusts
everything until somebody tries to push.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamRegistryJwksRequest
*/
func (a *IamAPIService) GetIamRegistryJwks(ctx context.Context) IamAPIGetIamRegistryJwksRequest {
return IamAPIGetIamRegistryJwksRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamRegistryJwksExecute(r IamAPIGetIamRegistryJwksRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamRegistryJwks")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/registry/jwks"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamRegistryTokenRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamRegistryTokenRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamRegistryTokenExecute(r)
}
/*
GetIamRegistryToken Signs a container client in to your registry.
Signs a container client in to your registry. `docker login`, and every
build tool that pushes or pulls images, lands here: it exchanges the
credential for a short-lived token scoped to exactly the repositories that
credential may touch.
Both of the shapes container tooling uses are accepted, so the same login works
whichever client your pipeline runs.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamRegistryTokenRequest
*/
func (a *IamAPIService) GetIamRegistryToken(ctx context.Context) IamAPIGetIamRegistryTokenRequest {
return IamAPIGetIamRegistryTokenRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamRegistryTokenExecute(r IamAPIGetIamRegistryTokenRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamRegistryToken")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/registry/token"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamRolesRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
}
func (r IamAPIGetIamRolesRequest) Owner(owner string) IamAPIGetIamRolesRequest {
r.owner = &owner
return r
}
func (r IamAPIGetIamRolesRequest) Execute() (*IamRolesListOutput, *http.Response, error) {
return r.ApiService.GetIamRolesExecute(r)
}
/*
GetIamRoles Returns your organization's roles, newest first — each a named group of people that permissions are granted to.
Returns your organization's roles, newest first — each a named group of
people that permissions are granted to.
You see your own organization's roles and no one else's; which organization
that is comes from your credentials, not from the request.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamRolesRequest
*/
func (a *IamAPIService) GetIamRoles(ctx context.Context) IamAPIGetIamRolesRequest {
return IamAPIGetIamRolesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamRolesListOutput
func (a *IamAPIService) GetIamRolesExecute(r IamAPIGetIamRolesRequest) (*IamRolesListOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamRolesListOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamRoles")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/roles"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "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 IamAPIGetIamRolesByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetIamRolesByOwnerByNameRequest) Execute() (*IamRole, *http.Response, error) {
return r.ApiService.GetIamRolesByOwnerByNameExecute(r)
}
/*
GetIamRolesByOwnerByName Returns one role: who is in it, and the roles it includes.
Returns one role: who is in it, and the roles it includes.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetIamRolesByOwnerByNameRequest
*/
func (a *IamAPIService) GetIamRolesByOwnerByName(ctx context.Context, owner string, name string) IamAPIGetIamRolesByOwnerByNameRequest {
return IamAPIGetIamRolesByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamRole
func (a *IamAPIService) GetIamRolesByOwnerByNameExecute(r IamAPIGetIamRolesByOwnerByNameRequest) (*IamRole, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamRole
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamRolesByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/roles/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetIamScimV2ResourcetypesRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamScimV2ResourcetypesRequest) Execute() (*IamListResponse, *http.Response, error) {
return r.ApiService.GetIamScimV2ResourcetypesExecute(r)
}
/*
GetIamScimV2Resourcetypes Returns the kinds of record this directory provisions and the address of each, so your identity provider discovers them rather than having them configured by hand.
Returns the kinds of record this directory provisions and
the address of each, so your identity provider discovers them rather than
having them configured by hand.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamScimV2ResourcetypesRequest
*/
func (a *IamAPIService) GetIamScimV2Resourcetypes(ctx context.Context) IamAPIGetIamScimV2ResourcetypesRequest {
return IamAPIGetIamScimV2ResourcetypesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamListResponse
func (a *IamAPIService) GetIamScimV2ResourcetypesExecute(r IamAPIGetIamScimV2ResourcetypesRequest) (*IamListResponse, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamListResponse
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamScimV2Resourcetypes")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/scim/v2/ResourceTypes"
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 IamAPIGetIamScimV2ResourcetypesByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
name string
}
func (r IamAPIGetIamScimV2ResourcetypesByNameRequest) Execute() (interface{}, *http.Response, error) {
return r.ApiService.GetIamScimV2ResourcetypesByNameExecute(r)
}
/*
GetIamScimV2ResourcetypesByName Returns one provisionable record kind in full.
Returns one provisionable record kind in full.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name
@return IamAPIGetIamScimV2ResourcetypesByNameRequest
*/
func (a *IamAPIService) GetIamScimV2ResourcetypesByName(ctx context.Context, name string) IamAPIGetIamScimV2ResourcetypesByNameRequest {
return IamAPIGetIamScimV2ResourcetypesByNameRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return interface{}
func (a *IamAPIService) GetIamScimV2ResourcetypesByNameExecute(r IamAPIGetIamScimV2ResourcetypesByNameRequest) (interface{}, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue interface{}
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamScimV2ResourcetypesByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/scim/v2/ResourceTypes/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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,
}
if localVarHTTPResponse.StatusCode == 404 {
var v interface{}
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
}
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 IamAPIGetIamScimV2SchemasRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamScimV2SchemasRequest) Execute() (*IamListResponse, *http.Response, error) {
return r.ApiService.GetIamScimV2SchemasExecute(r)
}
/*
GetIamScimV2Schemas Returns the attribute definitions this directory understands, so your identity provider knows which fields it may send and what they mean before it sends any.
Returns the attribute definitions this directory understands, so
your identity provider knows which fields it may send and what they mean
before it sends any.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamScimV2SchemasRequest
*/
func (a *IamAPIService) GetIamScimV2Schemas(ctx context.Context) IamAPIGetIamScimV2SchemasRequest {
return IamAPIGetIamScimV2SchemasRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamListResponse
func (a *IamAPIService) GetIamScimV2SchemasExecute(r IamAPIGetIamScimV2SchemasRequest) (*IamListResponse, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamListResponse
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamScimV2Schemas")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/scim/v2/Schemas"
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 IamAPIGetIamScimV2SchemasByIdRequest struct {
ctx context.Context
ApiService *IamAPIService
id string
}
func (r IamAPIGetIamScimV2SchemasByIdRequest) Execute() (interface{}, *http.Response, error) {
return r.ApiService.GetIamScimV2SchemasByIdExecute(r)
}
/*
GetIamScimV2SchemasById Returns one attribute definition in full.
Returns one attribute definition in full.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id
@return IamAPIGetIamScimV2SchemasByIdRequest
*/
func (a *IamAPIService) GetIamScimV2SchemasById(ctx context.Context, id string) IamAPIGetIamScimV2SchemasByIdRequest {
return IamAPIGetIamScimV2SchemasByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return interface{}
func (a *IamAPIService) GetIamScimV2SchemasByIdExecute(r IamAPIGetIamScimV2SchemasByIdRequest) (interface{}, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue interface{}
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamScimV2SchemasById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/scim/v2/Schemas/{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,
}
if localVarHTTPResponse.StatusCode == 404 {
var v interface{}
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
}
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 IamAPIGetIamScimV2ServiceproviderconfigRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamScimV2ServiceproviderconfigRequest) Execute() (*IamConfig, *http.Response, error) {
return r.ApiService.GetIamScimV2ServiceproviderconfigExecute(r)
}
/*
GetIamScimV2Serviceproviderconfig Tells your identity provider which parts of SCIM this directory supports, so it configures itself instead of you filling in a form.
Tells your identity provider which parts of SCIM this
directory supports, so it configures itself instead of you filling in a form.
Filtering and partial updates are supported. Bulk operations, sorting and
entity tags are not — an IdP that reads this will not attempt them.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamScimV2ServiceproviderconfigRequest
*/
func (a *IamAPIService) GetIamScimV2Serviceproviderconfig(ctx context.Context) IamAPIGetIamScimV2ServiceproviderconfigRequest {
return IamAPIGetIamScimV2ServiceproviderconfigRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamConfig
func (a *IamAPIService) GetIamScimV2ServiceproviderconfigExecute(r IamAPIGetIamScimV2ServiceproviderconfigRequest) (*IamConfig, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamConfig
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamScimV2Serviceproviderconfig")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/scim/v2/ServiceProviderConfig"
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 IamAPIGetIamScimV2UsersRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamScimV2UsersRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamScimV2UsersExecute(r)
}
/*
GetIamScimV2Users Returns the people in your organization to your identity provider, in the standard SCIM shape, so an IdP can reconcile its directory against ours.
Returns the people in your organization to your identity provider,
in the standard SCIM shape, so an IdP can reconcile its directory against
ours. Searchable by username or email address, and paged.
Reading the whole list takes an administrator; an ordinary person is refused.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamScimV2UsersRequest
*/
func (a *IamAPIService) GetIamScimV2Users(ctx context.Context) IamAPIGetIamScimV2UsersRequest {
return IamAPIGetIamScimV2UsersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamScimV2UsersExecute(r IamAPIGetIamScimV2UsersRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamScimV2Users")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/scim/v2/Users"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamScimV2UsersByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetIamScimV2UsersByOwnerByNameRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamScimV2UsersByOwnerByNameExecute(r)
}
/*
GetIamScimV2UsersByOwnerByName Returns one person in the standard SCIM shape.
Returns one person in the standard SCIM shape. An administrator may
read anyone in the organization; everyone else may read only themselves.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetIamScimV2UsersByOwnerByNameRequest
*/
func (a *IamAPIService) GetIamScimV2UsersByOwnerByName(ctx context.Context, owner string, name string) IamAPIGetIamScimV2UsersByOwnerByNameRequest {
return IamAPIGetIamScimV2UsersByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamScimV2UsersByOwnerByNameExecute(r IamAPIGetIamScimV2UsersByOwnerByNameRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamScimV2UsersByOwnerByName")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/scim/v2/Users/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamServiceAccountsRequest struct {
ctx context.Context
ApiService *IamAPIService
organization *string
p *int64
pageSize *int64
}
// Organization is the organization whose service accounts to list. Required.
func (r IamAPIGetIamServiceAccountsRequest) Organization(organization string) IamAPIGetIamServiceAccountsRequest {
r.organization = &organization
return r
}
// P is the 1-indexed page to return. Paging takes both p and pageSize — leave either out, or send something that is not a number, and the whole list comes back.
func (r IamAPIGetIamServiceAccountsRequest) P(p int64) IamAPIGetIamServiceAccountsRequest {
r.p = &p
return r
}
// Size is how many accounts a page holds.
func (r IamAPIGetIamServiceAccountsRequest) PageSize(pageSize int64) IamAPIGetIamServiceAccountsRequest {
r.pageSize = &pageSize
return r
}
func (r IamAPIGetIamServiceAccountsRequest) Execute() (*IamAnswer, *http.Response, error) {
return r.ApiService.GetIamServiceAccountsExecute(r)
}
/*
GetIamServiceAccounts Returns your organization's service accounts — what each is called and when it was created.
Returns your organization's service accounts — what each is called and
when it was created. Never their secrets: a key's secret half exists in a
response exactly once, when it is minted. Paginated in memory over the already org-scoped
slice — the set per org is small, so a dedicated count query is overkill
(v1 service_account.go:296-307).
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamServiceAccountsRequest
*/
func (a *IamAPIService) GetIamServiceAccounts(ctx context.Context) IamAPIGetIamServiceAccountsRequest {
return IamAPIGetIamServiceAccountsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamAnswer
func (a *IamAPIService) GetIamServiceAccountsExecute(r IamAPIGetIamServiceAccountsRequest) (*IamAnswer, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAnswer
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamServiceAccounts")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/service-accounts"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.organization != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "organization", r.organization, "form", "")
}
if r.p != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "p", r.p, "form", "")
}
if r.pageSize != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "pageSize", r.pageSize, "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,
}
if localVarHTTPResponse.StatusCode == 400 {
var v IamAnswer
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
}
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 IamAPIGetIamTeamsRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamTeamsRequest) Execute() (*IamTeamsListOutput, *http.Response, error) {
return r.ApiService.GetIamTeamsExecute(r)
}
/*
GetIamTeams Returns your organization's teams, newest first — each a named set of people that roles and permissions are granted to.
Returns your organization's teams, newest first — each a named set of
people that roles and permissions are granted to.
You see your own organization's teams and no one else's; which organization
that is comes from your credentials, not from the request.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamTeamsRequest
*/
func (a *IamAPIService) GetIamTeams(ctx context.Context) IamAPIGetIamTeamsRequest {
return IamAPIGetIamTeamsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamTeamsListOutput
func (a *IamAPIService) GetIamTeamsExecute(r IamAPIGetIamTeamsRequest) (*IamTeamsListOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamTeamsListOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamTeams")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/teams"
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 IamAPIGetIamTeamsByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
name string
}
func (r IamAPIGetIamTeamsByNameRequest) Execute() (*IamTeam, *http.Response, error) {
return r.ApiService.GetIamTeamsByNameExecute(r)
}
/*
GetIamTeamsByName Returns one team: who is in it.
Returns one team: who is in it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name
@return IamAPIGetIamTeamsByNameRequest
*/
func (a *IamAPIService) GetIamTeamsByName(ctx context.Context, name string) IamAPIGetIamTeamsByNameRequest {
return IamAPIGetIamTeamsByNameRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return IamTeam
func (a *IamAPIService) GetIamTeamsByNameExecute(r IamAPIGetIamTeamsByNameRequest) (*IamTeam, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamTeam
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamTeamsByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/teams/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetIamUsersRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
email *string
limit *int64
offset *int64
}
func (r IamAPIGetIamUsersRequest) Owner(owner string) IamAPIGetIamUsersRequest {
r.owner = &owner
return r
}
// Email narrows the page to the accounts carrying one address. Looking a person up by their address is a QUERY over the collection, not an item read: an address is not the natural key, two rows in one org can carry one, and a caller that gets a page SEES both — where a single-item read would have to choose, and choosing is how somebody joins a team under a colleague's identity.
func (r IamAPIGetIamUsersRequest) Email(email string) IamAPIGetIamUsersRequest {
r.email = &email
return r
}
func (r IamAPIGetIamUsersRequest) Limit(limit int64) IamAPIGetIamUsersRequest {
r.limit = &limit
return r
}
func (r IamAPIGetIamUsersRequest) Offset(offset int64) IamAPIGetIamUsersRequest {
r.offset = &offset
return r
}
func (r IamAPIGetIamUsersRequest) Execute() (*IamListOutput, *http.Response, error) {
return r.ApiService.GetIamUsersExecute(r)
}
/*
GetIamUsers Returns a page of the people in an organization, with the total so you can page through the rest.
Returns a page of the people in an organization, with the total so you
can page through the rest. Passwords, API secrets and MFA material are stripped
from every entry.
Which organization comes from your credentials, not from the request: you read
your own and no one else's, and a credential whose scope spans tenants reads
the tenant it names — or, naming none, every one of them.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamUsersRequest
*/
func (a *IamAPIService) GetIamUsers(ctx context.Context) IamAPIGetIamUsersRequest {
return IamAPIGetIamUsersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamListOutput
func (a *IamAPIService) GetIamUsersExecute(r IamAPIGetIamUsersRequest) (*IamListOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamListOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamUsers")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/users"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "form", "")
}
if r.email != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "email", r.email, "form", "")
}
if r.limit != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
}
if r.offset != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "offset", r.offset, "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 IamAPIGetIamUsersByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
email *string
}
func (r IamAPIGetIamUsersByOwnerByNameRequest) Email(email string) IamAPIGetIamUsersByOwnerByNameRequest {
r.email = &email
return r
}
func (r IamAPIGetIamUsersByOwnerByNameRequest) Execute() (*IamUser, *http.Response, error) {
return r.ApiService.GetIamUsersByOwnerByNameExecute(r)
}
/*
GetIamUsersByOwnerByName Returns one person in your organization, addressed by their username or by their email address.
Returns one person in your organization, addressed by their username or by
their email address. Passwords, API secrets and MFA material are stripped from
the response.
An address that names two accounts names none: the read refuses rather than
picking one, and says so instead of reporting "no such user". Handing back an
arbitrary one of two rows is how somebody gets added to a team under a
colleague's identity.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetIamUsersByOwnerByNameRequest
*/
func (a *IamAPIService) GetIamUsersByOwnerByName(ctx context.Context, owner string, name string) IamAPIGetIamUsersByOwnerByNameRequest {
return IamAPIGetIamUsersByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamUser
func (a *IamAPIService) GetIamUsersByOwnerByNameExecute(r IamAPIGetIamUsersByOwnerByNameRequest) (*IamUser, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamUser
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamUsersByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/users/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.email != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "email", r.email, "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 IamAPIGetIamWeb3NonceRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamWeb3NonceRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamWeb3NonceExecute(r)
}
/*
GetIamWeb3Nonce Starts a wallet sign-in: it returns a one-time challenge for the wallet to sign.
Starts a wallet sign-in: it returns a one-time challenge for the wallet
to sign. The challenge is good once and is tied to the site that asked for it,
so a signature collected elsewhere cannot be replayed here. Pass your
application's clientId and, from a page at one of its registered redirect
origins, the challenge names that page's site, which is what the wallet shows
the person.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamWeb3NonceRequest
*/
func (a *IamAPIService) GetIamWeb3Nonce(ctx context.Context) IamAPIGetIamWeb3NonceRequest {
return IamAPIGetIamWeb3NonceRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamWeb3NonceExecute(r IamAPIGetIamWeb3NonceRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamWeb3Nonce")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/web3/nonce"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamWebauthnSigninBeginRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamWebauthnSigninBeginRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamWebauthnSigninBeginExecute(r)
}
/*
GetIamWebauthnSigninBegin Starts a passkey sign-in: it returns the challenge the person's authenticator signs.
Starts a passkey sign-in: it returns the challenge the person's
authenticator signs.
The account is named in the query, and the challenge is bound to it, so what may
answer is decided here — by the server, from the row — and the finish checks the
answer against that decision rather than recomputing it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamWebauthnSigninBeginRequest
*/
func (a *IamAPIService) GetIamWebauthnSigninBegin(ctx context.Context) IamAPIGetIamWebauthnSigninBeginRequest {
return IamAPIGetIamWebauthnSigninBeginRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamWebauthnSigninBeginExecute(r IamAPIGetIamWebauthnSigninBeginRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamWebauthnSigninBegin")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/webauthn/signin/begin"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamWebauthnSignupBeginRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamWebauthnSignupBeginRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamWebauthnSignupBeginExecute(r)
}
/*
GetIamWebauthnSignupBegin Starts enrolling a passkey for the signed-in person: it returns the options their browser hands to the authenticator.
Starts enrolling a passkey for the signed-in person: it returns the
options their browser hands to the authenticator.
Passkeys already on the account are EXCLUDED, so a second enrollment on a device
that already holds one is refused by the authenticator itself rather than
silently producing a duplicate the person cannot tell apart.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamWebauthnSignupBeginRequest
*/
func (a *IamAPIService) GetIamWebauthnSignupBegin(ctx context.Context) IamAPIGetIamWebauthnSignupBeginRequest {
return IamAPIGetIamWebauthnSignupBeginRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamWebauthnSignupBeginExecute(r IamAPIGetIamWebauthnSignupBeginRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamWebauthnSignupBegin")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/webauthn/signup/begin"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamWellKnownJwksRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamWellKnownJwksRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamWellKnownJwksExecute(r)
}
/*
GetIamWellKnownJwks Publishes the public keys that verify the tokens issued here — the one URL you point a service at so it can check a token itself, offline, without calling back and without holding any secret of ours.
Publishes the public keys that verify the tokens issued here — the
one URL you point a service at so it can check a token itself, offline, without
calling back and without holding any secret of ours.
Keys appear here before they start signing and stay after they stop, so a
rotation never leaves a live token unverifiable. Nothing private is ever
published.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamWellKnownJwksRequest
*/
func (a *IamAPIService) GetIamWellKnownJwks(ctx context.Context) IamAPIGetIamWellKnownJwksRequest {
return IamAPIGetIamWellKnownJwksRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamWellKnownJwksExecute(r IamAPIGetIamWellKnownJwksRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamWellKnownJwks")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/.well-known/jwks"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamWellKnownOauthAuthorizationServerRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamWellKnownOauthAuthorizationServerRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamWellKnownOauthAuthorizationServerExecute(r)
}
/*
GetIamWellKnownOauthAuthorizationServer Returns the OpenID Connect discovery document — the one URL you point a standards-compliant client at so it can find every other endpoint on its own, instead of you configuring them by hand.
Returns the OpenID Connect discovery document — the one URL you
point a standards-compliant client at so it can find every other endpoint on
its own, instead of you configuring them by hand.
It advertises only what is actually implemented, so a client that reads it
cannot ask for a flow that will fail: the authorization-code flow, PKCE with
S256, the supported grants, and the signing algorithms whose public keys the
JWKS really publishes.
The issuer is derived from the host you asked on and is the same value the
tokens carry, so a client that pins the issuer never sees it change.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamWellKnownOauthAuthorizationServerRequest
*/
func (a *IamAPIService) GetIamWellKnownOauthAuthorizationServer(ctx context.Context) IamAPIGetIamWellKnownOauthAuthorizationServerRequest {
return IamAPIGetIamWellKnownOauthAuthorizationServerRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamWellKnownOauthAuthorizationServerExecute(r IamAPIGetIamWellKnownOauthAuthorizationServerRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamWellKnownOauthAuthorizationServer")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/.well-known/oauth-authorization-server"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamWellKnownOpenidConfigurationRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamWellKnownOpenidConfigurationRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamWellKnownOpenidConfigurationExecute(r)
}
/*
GetIamWellKnownOpenidConfiguration Returns the OpenID Connect discovery document — the one URL you point a standards-compliant client at so it can find every other endpoint on its own, instead of you configuring them by hand.
Returns the OpenID Connect discovery document — the one URL you
point a standards-compliant client at so it can find every other endpoint on
its own, instead of you configuring them by hand.
It advertises only what is actually implemented, so a client that reads it
cannot ask for a flow that will fail: the authorization-code flow, PKCE with
S256, the supported grants, and the signing algorithms whose public keys the
JWKS really publishes.
The issuer is derived from the host you asked on and is the same value the
tokens carry, so a client that pins the issuer never sees it change.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamWellKnownOpenidConfigurationRequest
*/
func (a *IamAPIService) GetIamWellKnownOpenidConfiguration(ctx context.Context) IamAPIGetIamWellKnownOpenidConfigurationRequest {
return IamAPIGetIamWellKnownOpenidConfigurationRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamWellKnownOpenidConfigurationExecute(r IamAPIGetIamWellKnownOpenidConfigurationRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamWellKnownOpenidConfiguration")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/.well-known/openid-configuration"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamWhoamiRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIGetIamWhoamiRequest) Execute() (*http.Response, error) {
return r.ApiService.GetIamWhoamiExecute(r)
}
/*
GetIamWhoami Tells you who the current caller is — the lightweight check a page makes on load to decide whether to render signed-in or signed-out.
Tells you who the current caller is — the lightweight check a
page makes on load to decide whether to render signed-in or signed-out.
It answers for a session cookie or a bearer token alike, and says plainly when
nobody is signed in rather than failing.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamWhoamiRequest
*/
func (a *IamAPIService) GetIamWhoami(ctx context.Context) IamAPIGetIamWhoamiRequest {
return IamAPIGetIamWhoamiRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) GetIamWhoamiExecute(r IamAPIGetIamWhoamiRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamWhoami")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/whoami"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIGetIamWorkspacesRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
}
func (r IamAPIGetIamWorkspacesRequest) Owner(owner string) IamAPIGetIamWorkspacesRequest {
r.owner = &owner
return r
}
func (r IamAPIGetIamWorkspacesRequest) Execute() (*IamWorkspacesListOutput, *http.Response, error) {
return r.ApiService.GetIamWorkspacesExecute(r)
}
/*
GetIamWorkspaces Returns your organization's workspaces, newest first — the scope a team works in, alongside projects rather than instead of them.
Returns your organization's workspaces, newest first — the scope a
team works in, alongside projects rather than instead of them.
You see your own organization's workspaces and no one else's; which organization that
is comes from your credentials, not from the request.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIGetIamWorkspacesRequest
*/
func (a *IamAPIService) GetIamWorkspaces(ctx context.Context) IamAPIGetIamWorkspacesRequest {
return IamAPIGetIamWorkspacesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamWorkspacesListOutput
func (a *IamAPIService) GetIamWorkspacesExecute(r IamAPIGetIamWorkspacesRequest) (*IamWorkspacesListOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamWorkspacesListOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamWorkspaces")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/workspaces"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "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 IamAPIGetIamWorkspacesByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetIamWorkspacesByOwnerByNameRequest) Execute() (*IamWorkspace, *http.Response, error) {
return r.ApiService.GetIamWorkspacesByOwnerByNameExecute(r)
}
/*
GetIamWorkspacesByOwnerByName Returns one workspace: what it is called and how it is set up.
Returns one workspace: what it is called and how it is set up.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetIamWorkspacesByOwnerByNameRequest
*/
func (a *IamAPIService) GetIamWorkspacesByOwnerByName(ctx context.Context, owner string, name string) IamAPIGetIamWorkspacesByOwnerByNameRequest {
return IamAPIGetIamWorkspacesByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamWorkspace
func (a *IamAPIService) GetIamWorkspacesByOwnerByNameExecute(r IamAPIGetIamWorkspacesByOwnerByNameRequest) (*IamWorkspace, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamWorkspace
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetIamWorkspacesByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/workspaces/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetOrganizationRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetOrganizationRequest) Execute() (*IamOrganization, *http.Response, error) {
return r.ApiService.GetOrganizationExecute(r)
}
/*
GetOrganization Returns one organization: its display, its defaults and the sign-in rules everyone in it inherits.
Returns one organization: its display, its defaults and the sign-in rules
everyone in it inherits.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetOrganizationRequest
*/
func (a *IamAPIService) GetOrganization(ctx context.Context, owner string, name string) IamAPIGetOrganizationRequest {
return IamAPIGetOrganizationRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamOrganization
func (a *IamAPIService) GetOrganizationExecute(r IamAPIGetOrganizationRequest) (*IamOrganization, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamOrganization
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetOrganization")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/organizations/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetOrganizationTombstoneRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetOrganizationTombstoneRequest) Execute() (*IamTombstone, *http.Response, error) {
return r.ApiService.GetOrganizationTombstoneExecute(r)
}
/*
GetOrganizationTombstone Returns what holds a deleted organization's name: when it was deleted and who founded it.
Returns what holds a deleted organization's name: when it was deleted
and who founded it. A SuperAdmin reads it before deciding to release the name.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetOrganizationTombstoneRequest
*/
func (a *IamAPIService) GetOrganizationTombstone(ctx context.Context, owner string, name string) IamAPIGetOrganizationTombstoneRequest {
return IamAPIGetOrganizationTombstoneRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamTombstone
func (a *IamAPIService) GetOrganizationTombstoneExecute(r IamAPIGetOrganizationTombstoneRequest) (*IamTombstone, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamTombstone
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetOrganizationTombstone")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/organizations/tombstones/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetProviderRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetProviderRequest) Execute() (*IamProviderResult, *http.Response, error) {
return r.ApiService.GetProviderExecute(r)
}
/*
GetProvider Returns one provider: what it connects to and how it is configured.
Returns one provider: what it connects to and how it is
configured. Its credentials come back masked.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetProviderRequest
*/
func (a *IamAPIService) GetProvider(ctx context.Context, owner string, name string) IamAPIGetProviderRequest {
return IamAPIGetProviderRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamProviderResult
func (a *IamAPIService) GetProviderExecute(r IamAPIGetProviderRequest) (*IamProviderResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamProviderResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetProvider")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/providers/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetSessionRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
application string
}
func (r IamAPIGetSessionRequest) Execute() (*IamSession, *http.Response, error) {
return r.ApiService.GetSessionExecute(r)
}
/*
GetSession Returns one person's session in one application — when it began and which browsers or devices are still carrying it.
Returns one person's session in one application — when it began and which
browsers or devices are still carrying it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@param application
@return IamAPIGetSessionRequest
*/
func (a *IamAPIService) GetSession(ctx context.Context, owner string, name string, application string) IamAPIGetSessionRequest {
return IamAPIGetSessionRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
application: application,
}
}
// Execute executes the request
//
// @return IamSession
func (a *IamAPIService) GetSessionExecute(r IamAPIGetSessionRequest) (*IamSession, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamSession
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetSession")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/sessions/{owner}/{name}/{application}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", url.PathEscape(parameterValueToString(r.application, "application")), -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 IamAPIGetTokenRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetTokenRequest) Execute() (*IamTokenResult, *http.Response, error) {
return r.ApiService.GetTokenExecute(r)
}
/*
GetToken Returns one access token: who and what it was issued to, and when it expires.
Returns one access token: who and what it was issued to, and when it
expires.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetTokenRequest
*/
func (a *IamAPIService) GetToken(ctx context.Context, owner string, name string) IamAPIGetTokenRequest {
return IamAPIGetTokenRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamTokenResult
func (a *IamAPIService) GetTokenExecute(r IamAPIGetTokenRequest) (*IamTokenResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamTokenResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetToken")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/tokens/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIGetWebauthnCredentialRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIGetWebauthnCredentialRequest) Execute() (*IamWebauthnCredentialResult, *http.Response, error) {
return r.ApiService.GetWebauthnCredentialExecute(r)
}
/*
GetWebauthnCredential Returns one passkey or security key: whose it is, what device it lives on, and when it was registered.
Returns one passkey or security key: whose it is, what
device it lives on, and when it was registered.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIGetWebauthnCredentialRequest
*/
func (a *IamAPIService) GetWebauthnCredential(ctx context.Context, owner string, name string) IamAPIGetWebauthnCredentialRequest {
return IamAPIGetWebauthnCredentialRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamWebauthnCredentialResult
func (a *IamAPIService) GetWebauthnCredentialExecute(r IamAPIGetWebauthnCredentialRequest) (*IamWebauthnCredentialResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamWebauthnCredentialResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.GetWebauthnCredential")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/webauthn-credentials/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPIListOrganizationsRequest struct {
ctx context.Context
ApiService *IamAPIService
xForwardedFor *string
q *string
limit *int64
cursor *string
}
func (r IamAPIListOrganizationsRequest) XForwardedFor(xForwardedFor string) IamAPIListOrganizationsRequest {
r.xForwardedFor = &xForwardedFor
return r
}
func (r IamAPIListOrganizationsRequest) Q(q string) IamAPIListOrganizationsRequest {
r.q = &q
return r
}
func (r IamAPIListOrganizationsRequest) Limit(limit int64) IamAPIListOrganizationsRequest {
r.limit = &limit
return r
}
func (r IamAPIListOrganizationsRequest) Cursor(cursor string) IamAPIListOrganizationsRequest {
r.cursor = &cursor
return r
}
func (r IamAPIListOrganizationsRequest) Execute() (*IamListOrganizationsOutput, *http.Response, error) {
return r.ApiService.ListOrganizationsExecute(r)
}
/*
ListOrganizations Returns the organizations you can act in, the ones you belong to first and the rest after, newest first, narrowed by an optional query against the name or the display name.
Returns the organizations you can act in, the ones you belong to first
and the rest after, newest first, narrowed by an optional query against the
name or the display name.
Platform operators see every organization; everyone else sees their own. Pass
the cursor from the previous page to continue; an empty cursor in the answer
means there is nothing more.
THE SCOPE IS THE HANDLER'S OWN, so it holds at every endpoint. The Guard refuses
a bearerless request before this runs, but the MCP server carries a typed op to
its handler with no middleware in front of it — a handler that read no
principal would answer such a caller with the whole registry. Reading the
principal here is what makes the answer the same one over both.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIListOrganizationsRequest
*/
func (a *IamAPIService) ListOrganizations(ctx context.Context) IamAPIListOrganizationsRequest {
return IamAPIListOrganizationsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamListOrganizationsOutput
func (a *IamAPIService) ListOrganizationsExecute(r IamAPIListOrganizationsRequest) (*IamListOrganizationsOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamListOrganizationsOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.ListOrganizations")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/organizations"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.q != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "q", r.q, "form", "")
}
if r.limit != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
}
if r.cursor != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "cursor", r.cursor, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
if r.xForwardedFor != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "X-Forwarded-For", r.xForwardedFor, "simple", "")
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type IamAPIListProvidersRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
}
func (r IamAPIListProvidersRequest) Owner(owner string) IamAPIListProvidersRequest {
r.owner = &owner
return r
}
func (r IamAPIListProvidersRequest) Execute() (*IamListProvidersOut, *http.Response, error) {
return r.ApiService.ListProvidersExecute(r)
}
/*
ListProviders Returns your organization's providers, newest first — the identity providers your people sign in with, and the senders and connectors your applications go through.
Returns your organization's providers, newest first — the
identity providers your people sign in with, and the senders and connectors
your applications go through.
You see your own organization's providers and no one else's; which organization
that is comes from your credentials, not from the request.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIListProvidersRequest
*/
func (a *IamAPIService) ListProviders(ctx context.Context) IamAPIListProvidersRequest {
return IamAPIListProvidersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamListProvidersOut
func (a *IamAPIService) ListProvidersExecute(r IamAPIListProvidersRequest) (*IamListProvidersOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamListProvidersOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.ListProviders")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/providers"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "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 IamAPIListSessionsRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
name *string
application *string
}
func (r IamAPIListSessionsRequest) Owner(owner string) IamAPIListSessionsRequest {
r.owner = &owner
return r
}
func (r IamAPIListSessionsRequest) Name(name string) IamAPIListSessionsRequest {
r.name = &name
return r
}
func (r IamAPIListSessionsRequest) Application(application string) IamAPIListSessionsRequest {
r.application = &application
return r
}
func (r IamAPIListSessionsRequest) Execute() (*IamListSessionsOut, *http.Response, error) {
return r.ApiService.ListSessionsExecute(r)
}
/*
ListSessions Returns who is currently signed in to an organization, newest first, and can be narrowed to one person or one application.
Returns who is currently signed in to an organization, newest first, and
can be narrowed to one person or one application. It is what you read before
signing someone out.
Which organization comes from your credentials, not from the request: you read
your own and no one else's. A session row names a live account and the
applications it is signed in to, so the tenant is decided here rather than
taken from the query.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIListSessionsRequest
*/
func (a *IamAPIService) ListSessions(ctx context.Context) IamAPIListSessionsRequest {
return IamAPIListSessionsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamListSessionsOut
func (a *IamAPIService) ListSessionsExecute(r IamAPIListSessionsRequest) (*IamListSessionsOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamListSessionsOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.ListSessions")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/sessions"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "form", "")
}
if r.name != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "name", r.name, "form", "")
}
if r.application != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "application", r.application, "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 IamAPIListTokensRequest struct {
ctx context.Context
ApiService *IamAPIService
owner *string
organization *string
}
func (r IamAPIListTokensRequest) Owner(owner string) IamAPIListTokensRequest {
r.owner = &owner
return r
}
func (r IamAPIListTokensRequest) Organization(organization string) IamAPIListTokensRequest {
r.organization = &organization
return r
}
func (r IamAPIListTokensRequest) Execute() (*IamListTokensOut, *http.Response, error) {
return r.ApiService.ListTokensExecute(r)
}
/*
ListTokens Returns the access tokens issued in your organization, newest first, and can be narrowed to one organization.
Returns the access tokens issued in your organization, newest
first, and can be narrowed to one organization. Use it to see what is currently
authorized before revoking anything.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIListTokensRequest
*/
func (a *IamAPIService) ListTokens(ctx context.Context) IamAPIListTokensRequest {
return IamAPIListTokensRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamListTokensOut
func (a *IamAPIService) ListTokensExecute(r IamAPIListTokensRequest) (*IamListTokensOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamListTokensOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.ListTokens")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/tokens"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.owner != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "owner", r.owner, "form", "")
}
if r.organization != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "organization", r.organization, "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 IamAPIListWebauthnCredentialsRequest struct {
ctx context.Context
ApiService *IamAPIService
user *string
}
func (r IamAPIListWebauthnCredentialsRequest) User(user string) IamAPIListWebauthnCredentialsRequest {
r.user = &user
return r
}
func (r IamAPIListWebauthnCredentialsRequest) Execute() (*IamListWebauthnCredentialsOut, *http.Response, error) {
return r.ApiService.ListWebauthnCredentialsExecute(r)
}
/*
ListWebauthnCredentials Returns the passkeys and security keys registered to one person, newest first — which device each lives on and when it was registered.
Returns the passkeys and security keys registered to
one person, newest first — which device each lives on and when it was
registered.
Yours by default. Name somebody else and you get them only if you already
administer their account, which is the same authority that governs reading
their user record — so this list can never show more people than the surface
beside it already does.
There is no organization-wide list, by design. Scoping to the ORG would hand an
org admin every member's credential rows in one answer and a SuperAdmin every
tenant's, while a plain member could not read even their own (an unnamed target
fails the Guard's tenant rule). One scope answers both halves cleanly: the
answer is a person's, and the caller is that person unless they say otherwise
and may.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIListWebauthnCredentialsRequest
*/
func (a *IamAPIService) ListWebauthnCredentials(ctx context.Context) IamAPIListWebauthnCredentialsRequest {
return IamAPIListWebauthnCredentialsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamListWebauthnCredentialsOut
func (a *IamAPIService) ListWebauthnCredentialsExecute(r IamAPIListWebauthnCredentialsRequest) (*IamListWebauthnCredentialsOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamListWebauthnCredentialsOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.ListWebauthnCredentials")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/webauthn-credentials"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.user != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "user", r.user, "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 IamAPIPatchIamScimV2UsersByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIPatchIamScimV2UsersByOwnerByNameRequest) Execute() (*http.Response, error) {
return r.ApiService.PatchIamScimV2UsersByOwnerByNameExecute(r)
}
/*
PatchIamScimV2UsersByOwnerByName Applies a partial change from your identity provider — one attribute moved, not the whole record resent.
Applies a partial change from your identity provider — one attribute
moved, not the whole record resent.
The change is applied onto the person as they currently are, so everything you
did not mention keeps its value, including the parts SCIM does not describe.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIPatchIamScimV2UsersByOwnerByNameRequest
*/
func (a *IamAPIService) PatchIamScimV2UsersByOwnerByName(ctx context.Context, owner string, name string) IamAPIPatchIamScimV2UsersByOwnerByNameRequest {
return IamAPIPatchIamScimV2UsersByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
func (a *IamAPIService) PatchIamScimV2UsersByOwnerByNameExecute(r IamAPIPatchIamScimV2UsersByOwnerByNameRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPatch
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PatchIamScimV2UsersByOwnerByName")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/scim/v2/Users/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamAdminProvisionRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamAdminProvisionRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamAdminProvisionExecute(r)
}
/*
PostIamAdminProvision Founds an org on someone's behalf — the same onboarding a person gets themselves, driven by one of your own services instead of by them.
Founds an org on someone's behalf — the same onboarding
a person gets themselves, driven by one of your own services instead of by
them. The person keeps their account and owns the org by membership.
It authenticates as your service rather than as a person, which is why the
person to provision is named in the request. The setup it performs is
identical to self-service onboarding; there is one provisioning path, not
two that can drift.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamAdminProvisionRequest
*/
func (a *IamAPIService) PostIamAdminProvision(ctx context.Context) IamAPIPostIamAdminProvisionRequest {
return IamAPIPostIamAdminProvisionRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamAdminProvisionExecute(r IamAPIPostIamAdminProvisionRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamAdminProvision")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/admin/provision"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamApplicationsRequest struct {
ctx context.Context
ApiService *IamAPIService
iamApplication *IamApplication
}
func (r IamAPIPostIamApplicationsRequest) IamApplication(iamApplication IamApplication) IamAPIPostIamApplicationsRequest {
r.iamApplication = &iamApplication
return r
}
func (r IamAPIPostIamApplicationsRequest) Execute() (*IamApplication, *http.Response, error) {
return r.ApiService.PostIamApplicationsExecute(r)
}
/*
PostIamApplications Registers an application in your organization — one product or site your people sign in to, with its own client credentials, sign-in methods and allowed redirect URIs.
Registers an application in your organization — one product or site
your people sign in to, with its own client credentials, sign-in methods and
allowed redirect URIs. A name already used in the organization is refused
rather than overwritten. An application that serves other organizations —
isShared, or any orgChoiceMode but "" and "None" — is created by a SuperAdmin
only.
Exported so the legacy add-application alias reuses this exact path — one
create, two spellings.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamApplicationsRequest
*/
func (a *IamAPIService) PostIamApplications(ctx context.Context) IamAPIPostIamApplicationsRequest {
return IamAPIPostIamApplicationsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamApplication
func (a *IamAPIService) PostIamApplicationsExecute(r IamAPIPostIamApplicationsRequest) (*IamApplication, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamApplication
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamApplications")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/applications"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamApplication == nil {
return localVarReturnValue, nil, reportError("iamApplication 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.iamApplication
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 IamAPIPostIamAuditLogsRequest struct {
ctx context.Context
ApiService *IamAPIService
iamAuditlogsInput *IamAuditlogsInput
}
func (r IamAPIPostIamAuditLogsRequest) IamAuditlogsInput(iamAuditlogsInput IamAuditlogsInput) IamAPIPostIamAuditLogsRequest {
r.iamAuditlogsInput = &iamAuditlogsInput
return r
}
func (r IamAPIPostIamAuditLogsRequest) Execute() (*IamAuditLog, *http.Response, error) {
return r.ApiService.PostIamAuditLogsExecute(r)
}
/*
PostIamAuditLogs Records an audit entry, so activity from your own systems lands in the same trail as everything the Hanzo Cloud records for you.
Records an audit entry, so activity from your own systems lands in the
same trail as everything the Hanzo Cloud records for you.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamAuditLogsRequest
*/
func (a *IamAPIService) PostIamAuditLogs(ctx context.Context) IamAPIPostIamAuditLogsRequest {
return IamAPIPostIamAuditLogsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamAuditLog
func (a *IamAPIService) PostIamAuditLogsExecute(r IamAPIPostIamAuditLogsRequest) (*IamAuditLog, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAuditLog
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamAuditLogs")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/audit-logs"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamAuditlogsInput == nil {
return localVarReturnValue, nil, reportError("iamAuditlogsInput 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.iamAuditlogsInput
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 IamAPIPostIamAuthIdentifierRequest struct {
ctx context.Context
ApiService *IamAPIService
iamIdentifierBody *IamIdentifierBody
cFConnectingIP *string
xForwardedFor *string
}
func (r IamAPIPostIamAuthIdentifierRequest) IamIdentifierBody(iamIdentifierBody IamIdentifierBody) IamAPIPostIamAuthIdentifierRequest {
r.iamIdentifierBody = &iamIdentifierBody
return r
}
func (r IamAPIPostIamAuthIdentifierRequest) CFConnectingIP(cFConnectingIP string) IamAPIPostIamAuthIdentifierRequest {
r.cFConnectingIP = &cFConnectingIP
return r
}
func (r IamAPIPostIamAuthIdentifierRequest) XForwardedFor(xForwardedFor string) IamAPIPostIamAuthIdentifierRequest {
r.xForwardedFor = &xForwardedFor
return r
}
func (r IamAPIPostIamAuthIdentifierRequest) Execute() (*IamAnswer, *http.Response, error) {
return r.ApiService.PostIamAuthIdentifierExecute(r)
}
/*
PostIamAuthIdentifier Answers whether an account holds an email address at an application, and whether that account signs in with a password.
Answers whether an account holds an email address at an
application, and whether that account signs in with a password. Only an
application that registers strangers answers, since its signup says as much
already. The address is resolved exactly as sign-in resolves it, so the screen
and the sign-in cannot disagree. A client asking faster than a person types is
refused with 429.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamAuthIdentifierRequest
*/
func (a *IamAPIService) PostIamAuthIdentifier(ctx context.Context) IamAPIPostIamAuthIdentifierRequest {
return IamAPIPostIamAuthIdentifierRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamAnswer
func (a *IamAPIService) PostIamAuthIdentifierExecute(r IamAPIPostIamAuthIdentifierRequest) (*IamAnswer, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAnswer
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamAuthIdentifier")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/auth/identifier"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamIdentifierBody == nil {
return localVarReturnValue, nil, reportError("iamIdentifierBody 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
}
if r.cFConnectingIP != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "CF-Connecting-IP", r.cFConnectingIP, "simple", "")
}
if r.xForwardedFor != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "X-Forwarded-For", r.xForwardedFor, "simple", "")
}
// body params
localVarPostBody = r.iamIdentifierBody
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,
}
if localVarHTTPResponse.StatusCode == 400 {
var v IamAnswer
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
}
if localVarHTTPResponse.StatusCode == 429 {
var v IamAnswer
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
}
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 IamAPIPostIamCertsRequest struct {
ctx context.Context
ApiService *IamAPIService
iamCert *IamCert
}
func (r IamAPIPostIamCertsRequest) IamCert(iamCert IamCert) IamAPIPostIamCertsRequest {
r.iamCert = &iamCert
return r
}
func (r IamAPIPostIamCertsRequest) Execute() (*IamCert, *http.Response, error) {
return r.ApiService.PostIamCertsExecute(r)
}
/*
PostIamCerts Adds a signing certificate your applications can verify tokens against — the call you make to stage the next one before a rotation.
Adds a signing certificate your applications can verify tokens against
— the call you make to stage the next one before a rotation. A name already
used in your organization is refused.
It registers the certificate's IDENTITY: its name (which is the JWKS `kid`),
its algorithm, its expiry. Key material does not travel this way and cannot:
the private key is not part of the Cert's JSON, so it is neither served here
nor accepted here. It is supplied to the process by the deployment, under the
name registered here (internal/keyring). Staging a rotation is therefore two
halves — this call names the key, and the deployment provides it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamCertsRequest
*/
func (a *IamAPIService) PostIamCerts(ctx context.Context) IamAPIPostIamCertsRequest {
return IamAPIPostIamCertsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamCert
func (a *IamAPIService) PostIamCertsExecute(r IamAPIPostIamCertsRequest) (*IamCert, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamCert
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamCerts")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/certs"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamCert == nil {
return localVarReturnValue, nil, reportError("iamCert 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.iamCert
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 IamAPIPostIamDeleteMembershipRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamDeleteMembershipRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamDeleteMembershipExecute(r)
}
/*
PostIamDeleteMembership Takes away a person's or an application's right to act in an organization.
Takes away a person's or an application's right to act in an
organization. Their account survives; what ends is their access to that
organization. Revoking a membership that is already gone reports that nothing
was removed rather than failing, so a retry is safe. It is the mirror of ensure and takes the SAME gate:
revoking membership is the org's authority to give or take, so a SuperAdmin, an
admin of the org itself, or an org-admin-capable confidential client. Idempotent
through the store — deleting an absent membership reports removed=false, never an
error — so a retried revoke is safe.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamDeleteMembershipRequest
*/
func (a *IamAPIService) PostIamDeleteMembership(ctx context.Context) IamAPIPostIamDeleteMembershipRequest {
return IamAPIPostIamDeleteMembershipRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamDeleteMembershipExecute(r IamAPIPostIamDeleteMembershipRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamDeleteMembership")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/delete-membership"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamInvitationsRequest struct {
ctx context.Context
ApiService *IamAPIService
iamInvitationsInput *IamInvitationsInput
}
func (r IamAPIPostIamInvitationsRequest) IamInvitationsInput(iamInvitationsInput IamInvitationsInput) IamAPIPostIamInvitationsRequest {
r.iamInvitationsInput = &iamInvitationsInput
return r
}
func (r IamAPIPostIamInvitationsRequest) Execute() (*IamInvitation, *http.Response, error) {
return r.ApiService.PostIamInvitationsExecute(r)
}
/*
PostIamInvitations Issues an invitation to join your organization — the code or link a new member redeems, with the role they arrive holding and the date it stops working.
Issues an invitation to join your organization — the code or link a new
member redeems, with the role they arrive holding and the date it stops
working. A name already used in the organization is refused.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamInvitationsRequest
*/
func (a *IamAPIService) PostIamInvitations(ctx context.Context) IamAPIPostIamInvitationsRequest {
return IamAPIPostIamInvitationsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamInvitation
func (a *IamAPIService) PostIamInvitationsExecute(r IamAPIPostIamInvitationsRequest) (*IamInvitation, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamInvitation
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamInvitations")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/invitations"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamInvitationsInput == nil {
return localVarReturnValue, nil, reportError("iamInvitationsInput 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.iamInvitationsInput
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 IamAPIPostIamInvitationsAcceptRequest struct {
ctx context.Context
ApiService *IamAPIService
iamAcceptBody *IamAcceptBody
cookie *string
authorization *string
secFetchSite *string
origin *string
host *string
contentType *string
}
func (r IamAPIPostIamInvitationsAcceptRequest) IamAcceptBody(iamAcceptBody IamAcceptBody) IamAPIPostIamInvitationsAcceptRequest {
r.iamAcceptBody = &iamAcceptBody
return r
}
func (r IamAPIPostIamInvitationsAcceptRequest) Cookie(cookie string) IamAPIPostIamInvitationsAcceptRequest {
r.cookie = &cookie
return r
}
func (r IamAPIPostIamInvitationsAcceptRequest) Authorization(authorization string) IamAPIPostIamInvitationsAcceptRequest {
r.authorization = &authorization
return r
}
func (r IamAPIPostIamInvitationsAcceptRequest) SecFetchSite(secFetchSite string) IamAPIPostIamInvitationsAcceptRequest {
r.secFetchSite = &secFetchSite
return r
}
func (r IamAPIPostIamInvitationsAcceptRequest) Origin(origin string) IamAPIPostIamInvitationsAcceptRequest {
r.origin = &origin
return r
}
func (r IamAPIPostIamInvitationsAcceptRequest) Host(host string) IamAPIPostIamInvitationsAcceptRequest {
r.host = &host
return r
}
func (r IamAPIPostIamInvitationsAcceptRequest) ContentType(contentType string) IamAPIPostIamInvitationsAcceptRequest {
r.contentType = &contentType
return r
}
func (r IamAPIPostIamInvitationsAcceptRequest) Execute() (*IamAnswer, *http.Response, error) {
return r.ApiService.PostIamInvitationsAcceptExecute(r)
}
/*
PostIamInvitationsAccept Joins the caller to an organization through an invitation, for a person who already has an account.
Joins the caller to an organization through an invitation, for
a person who already has an account. Signing up through the invitation is the
other way in (signupHandler); this one spends the same seat under the same rules.
Only the caller joins, as a member and never more; the request names nobody
else. An invitation pinned to an address admits only the account holding that
address, and only with a code IAM sent to it for this join — the account's own
verified flag is not enough, because a tenant's identity provider can set it. An
invitation pinned to a phone number or a username admits no other org's account
this way. Joining an org the caller already belongs to succeeds and spends
nothing. Every refusal is recorded, and an account refused acceptLimit times in
acceptWindow is refused before anything is looked at.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamInvitationsAcceptRequest
*/
func (a *IamAPIService) PostIamInvitationsAccept(ctx context.Context) IamAPIPostIamInvitationsAcceptRequest {
return IamAPIPostIamInvitationsAcceptRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamAnswer
func (a *IamAPIService) PostIamInvitationsAcceptExecute(r IamAPIPostIamInvitationsAcceptRequest) (*IamAnswer, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAnswer
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamInvitationsAccept")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/invitations/accept"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamAcceptBody == nil {
return localVarReturnValue, nil, reportError("iamAcceptBody 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
}
if r.cookie != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Cookie", r.cookie, "simple", "")
}
if r.authorization != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
}
if r.secFetchSite != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Sec-Fetch-Site", r.secFetchSite, "simple", "")
}
if r.origin != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Origin", r.origin, "simple", "")
}
if r.host != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Host", r.host, "simple", "")
}
if r.contentType != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Content-Type", r.contentType, "simple", "")
}
// body params
localVarPostBody = r.iamAcceptBody
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,
}
if localVarHTTPResponse.StatusCode == 400 {
var v IamAnswer
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
}
if localVarHTTPResponse.StatusCode == 403 {
var v IamAnswer
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
}
if localVarHTTPResponse.StatusCode == 429 {
var v IamAnswer
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
}
if localVarHTTPResponse.StatusCode == 502 {
var v IamAnswer
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
}
if localVarHTTPResponse.StatusCode == 503 {
var v IamAnswer
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
}
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 IamAPIPostIamInvitationsByOwnerByNameSendRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
authorization *string
}
func (r IamAPIPostIamInvitationsByOwnerByNameSendRequest) Authorization(authorization string) IamAPIPostIamInvitationsByOwnerByNameSendRequest {
r.authorization = &authorization
return r
}
func (r IamAPIPostIamInvitationsByOwnerByNameSendRequest) Execute() (*IamSendOutput, *http.Response, error) {
return r.ApiService.PostIamInvitationsByOwnerByNameSendExecute(r)
}
/*
PostIamInvitationsByOwnerByNameSend Emails an invitation to the address it is pinned to: who invited them, to which organization, and the link that joins them.
Emails an invitation to the address it is pinned to: who invited them, to
which organization, and the link that joins them.
The caller chooses nothing about how it goes out. It is sent through the
platform application the caller's access token was issued to, from that
application's org's email account, with a link on the identity host that issued
the token — the way the inviter came in. Only the pinned address receives it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIPostIamInvitationsByOwnerByNameSendRequest
*/
func (a *IamAPIService) PostIamInvitationsByOwnerByNameSend(ctx context.Context, owner string, name string) IamAPIPostIamInvitationsByOwnerByNameSendRequest {
return IamAPIPostIamInvitationsByOwnerByNameSendRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamSendOutput
func (a *IamAPIService) PostIamInvitationsByOwnerByNameSendExecute(r IamAPIPostIamInvitationsByOwnerByNameSendRequest) (*IamSendOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamSendOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamInvitationsByOwnerByNameSend")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/invitations/{owner}/{name}/send"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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
}
if r.authorization != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type IamAPIPostIamKeysRequest struct {
ctx context.Context
ApiService *IamAPIService
iamKey *IamKey
}
func (r IamAPIPostIamKeysRequest) IamKey(iamKey IamKey) IamAPIPostIamKeysRequest {
r.iamKey = &iamKey
return r
}
func (r IamAPIPostIamKeysRequest) Execute() (*IamKey, *http.Response, error) {
return r.ApiService.PostIamKeysExecute(r)
}
/*
PostIamKeys Issues an API key.
Issues an API key. A standard key comes back as a publishable half you
may ship in client code and a secret half you must not — the secret is shown
once, at creation, and cannot be retrieved afterwards. A publish-scoped key is
issued with the publishable half only, so there is no secret to leak.
A name already used in your organization is refused rather than reissued, so
creating twice never silently invalidates a key that is in production.
A key you create is yours: it names you as its holder and speaks for you in the
organization it is filed in. Naming anyone else as its holder is refused; a
SuperAdmin names the person a key is for.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamKeysRequest
*/
func (a *IamAPIService) PostIamKeys(ctx context.Context) IamAPIPostIamKeysRequest {
return IamAPIPostIamKeysRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamKey
func (a *IamAPIService) PostIamKeysExecute(r IamAPIPostIamKeysRequest) (*IamKey, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamKey
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamKeys")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/keys"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamKey == nil {
return localVarReturnValue, nil, reportError("iamKey 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.iamKey
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 IamAPIPostIamLinkRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamLinkRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamLinkExecute(r)
}
/*
PostIamLink Starts connecting another sign-in identity to the account you are already signed in as.
Starts connecting another sign-in identity to the account you are already
signed in as. It answers with an address for your browser to open; from there
you go to the provider, and when it returns, that identity is attached and you
come back to returnUri. Only the browser where you are signed in here can carry
a link through.
Your account is fixed here, from the credential you are already holding, and is
carried server-side for the rest of the round-trip — so nothing that happens at
the provider can point the link at somebody else.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamLinkRequest
*/
func (a *IamAPIService) PostIamLink(ctx context.Context) IamAPIPostIamLinkRequest {
return IamAPIPostIamLinkRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamLinkExecute(r IamAPIPostIamLinkRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamLink")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamLoginRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamLoginRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamLoginExecute(r)
}
/*
PostIamLogin Signs a person in with the credential they typed, and — when the request is part of an OAuth flow — hands back the one-time code that finishes it.
Signs a person in with the credential they typed, and — when the
request is part of an OAuth flow — hands back the one-time code that finishes
it. A second factor, if the account has one, is asked for and required here.
The password is compared against a stored one-way hash and is never logged,
echoed or stored as typed.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamLoginRequest
*/
func (a *IamAPIService) PostIamLogin(ctx context.Context) IamAPIPostIamLoginRequest {
return IamAPIPostIamLoginRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamLoginExecute(r IamAPIPostIamLoginRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamLogin")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/login"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamMembershipsRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamMembershipsRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamMembershipsExecute(r)
}
/*
PostIamMemberships Lets a person or an application act in an organization.
Lets a person or an application act in an organization. It is the grant
behind "add someone to the team", and it is safe to repeat — granting a
membership that already exists changes nothing. Granting membership IS the org's authority to give, so it takes the
same gate a write to that org's own registry row takes: a SuperAdmin, an admin
of the org itself, or an org-admin-capable confidential client. One rule, one
place (internal/authz).
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamMembershipsRequest
*/
func (a *IamAPIService) PostIamMemberships(ctx context.Context) IamAPIPostIamMembershipsRequest {
return IamAPIPostIamMembershipsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamMembershipsExecute(r IamAPIPostIamMembershipsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamMemberships")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/memberships"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamMfaPreferredRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamMfaPreferredRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamMfaPreferredExecute(r)
}
/*
PostIamMfaPreferred Picks which second factor an account is asked for first when it has more than one.
Picks which second factor an account is asked for first when it has
more than one. Only a factor the account actually holds: storing an unheld one told
the login gate "MFA is on" — factor.Enabled reads that column — while leaving it
nothing to ask for, so the sign-in required the password alone.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamMfaPreferredRequest
*/
func (a *IamAPIService) PostIamMfaPreferred(ctx context.Context) IamAPIPostIamMfaPreferredRequest {
return IamAPIPostIamMfaPreferredRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamMfaPreferredExecute(r IamAPIPostIamMfaPreferredRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamMfaPreferred")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/mfa/preferred"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamMfaSetupEnableRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamMfaSetupEnableRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamMfaSetupEnableExecute(r)
}
/*
PostIamMfaSetupEnable Finishes the enrolment: from here the account's sign-ins ask for this factor.
Finishes the enrolment: from here the account's sign-ins ask for this factor.
It requires the proof initiate handed out — a passcode from the authenticator, or the
code that was sent — and verifies it BEFORE writing anything.
Verifying BEFORE writing is what keeps a client that never completed the proof —
a skipped verify step, a QR scanned into the wrong app, a bug — from switching on
a factor no code can satisfy. That would lock the account out with no
self-service way back: the gate holds the sign-in before minting, so the person
could not obtain the bearer that disable requires.
The recovery codes are minted here and returned ONCE, on the first factor the
account adds. Answering with them is the way back in when no factor can be
produced, so they are the same value the row's digests were made from — by
construction, not by a client echoing them back.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamMfaSetupEnableRequest
*/
func (a *IamAPIService) PostIamMfaSetupEnable(ctx context.Context) IamAPIPostIamMfaSetupEnableRequest {
return IamAPIPostIamMfaSetupEnableRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamMfaSetupEnableExecute(r IamAPIPostIamMfaSetupEnableRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamMfaSetupEnable")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/mfa/setup/enable"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamMfaSetupInitiateRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamMfaSetupInitiateRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamMfaSetupInitiateExecute(r)
}
/*
PostIamMfaSetupInitiate Starts enrolling a factor and hands over whatever the person needs to prove they hold it: app a fresh secret and the otpauth:// URL to render as a QR code sms a code texted to the number on the account email a code mailed to the address on the account Nothing is switched on yet, so abandoning this step leaves the account exactly as it was.
Starts enrolling a factor and hands over whatever the person needs to prove
they hold it:
app a fresh secret and the otpauth:// URL to render as a QR code
sms a code texted to the number on the account
email a code mailed to the address on the account
Nothing is switched on yet, so abandoning this step leaves the account exactly as
it was. Response: {status:"ok", data:{mfaType, secret, url}} — secret and url only
for the authenticator.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamMfaSetupInitiateRequest
*/
func (a *IamAPIService) PostIamMfaSetupInitiate(ctx context.Context) IamAPIPostIamMfaSetupInitiateRequest {
return IamAPIPostIamMfaSetupInitiateRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamMfaSetupInitiateExecute(r IamAPIPostIamMfaSetupInitiateRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamMfaSetupInitiate")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/mfa/setup/initiate"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamOauthAuthorizeRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamOauthAuthorizeRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamOauthAuthorizeExecute(r)
}
/*
PostIamOauthAuthorize Starts a sign-in — the address you send a browser to, and the beginning of every OAuth and OpenID Connect flow.
Starts a sign-in — the address you send a browser to, and the
beginning of every OAuth and OpenID Connect flow.
If the person is ALREADY signed in here, it does not ask them again: it
returns them to the application with a one-time code and they never see this
page. Otherwise it shows the right way to sign in for the application they are
signing in to, or hands off to another identity provider if that is what they
pick.
A client can say what it wants with `prompt`: `none` means answer without any
screen at all — with the code if a session exists, with an error if not, but
never with a page; `login` means ask for the password again even if a session
exists; `select_account` means let the person choose among the accounts signed
in on this browser, or sign in to another. `login_hint` names which of those
accounts the request is for.
It returns only to an address the application has registered. That check
happens before anything else, so a request naming an unregistered address is
refused where the person can see it rather than being bounced onwards.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamOauthAuthorizeRequest
*/
func (a *IamAPIService) PostIamOauthAuthorize(ctx context.Context) IamAPIPostIamOauthAuthorizeRequest {
return IamAPIPostIamOauthAuthorizeRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamOauthAuthorizeExecute(r IamAPIPostIamOauthAuthorizeRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamOauthAuthorize")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/authorize"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamOauthCallbackRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamOauthCallbackRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamOauthCallbackExecute(r)
}
/*
PostIamOauthCallback Completes the round-trip: it resolves and burns the single-use transaction (checking expiry + browser binding), exchanges and verifies the IdP response, links or provisions the local user, and mints the iam authorization code the relying party expects — then redirects to the original redirect_uri with code + state.
Completes the round-trip: it resolves and burns the
single-use transaction (checking expiry + browser binding), exchanges and
verifies the IdP response, links or provisions the local user, and mints the
iam authorization code the relying party expects — then redirects to the
original redirect_uri with code + state. A redirect provider's reply is read
from the query of its GET. A form_post provider's POST is answered with a 303
to a GET of this address naming a single-use handoff that holds the reply, and
that GET finishes the sign-in.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamOauthCallbackRequest
*/
func (a *IamAPIService) PostIamOauthCallback(ctx context.Context) IamAPIPostIamOauthCallbackRequest {
return IamAPIPostIamOauthCallbackRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamOauthCallbackExecute(r IamAPIPostIamOauthCallbackRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamOauthCallback")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/callback"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamOauthDeviceRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamOauthDeviceRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamOauthDeviceExecute(r)
}
/*
PostIamOauthDevice Starts a sign-in on a device with no browser and no keyboard — a TV, a CLI, a headless box.
Starts a sign-in on a device with no browser and no keyboard —
a TV, a CLI, a headless box. It returns a short code to show the person and
the address to send them to on a phone or laptop.
Nothing is granted until a human approves it there; until then the code is
just a pending request.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamOauthDeviceRequest
*/
func (a *IamAPIService) PostIamOauthDevice(ctx context.Context) IamAPIPostIamOauthDeviceRequest {
return IamAPIPostIamOauthDeviceRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamOauthDeviceExecute(r IamAPIPostIamOauthDeviceRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamOauthDevice")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/device"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamOauthDeviceInfoRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamOauthDeviceInfoRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamOauthDeviceInfoExecute(r)
}
/*
PostIamOauthDeviceInfo Answers \"what am I approving?\" for a pending device code.
Answers "what am I approving?" for a pending device code.
The approval page exists to tell a human WHICH application they are authorizing;
a page that names any other one defeats the control it implements. The client is
a property of the CODE, not of the page or of whatever app the browser happens
to be signed in to, so it is read from the code's row here and nowhere else.
Requires a signed-in session, and answers with the same ONE opaque refusal
approveDevice uses. That is deliberate: the user_code is only 40 bits and is the
one secret in this flow, so an unauthenticated lookup — or one that
distinguished unknown from expired from already-approved — would be an oracle
for hunting live codes. Gated and opaque, it reveals strictly less than the
approval the same caller could already attempt.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamOauthDeviceInfoRequest
*/
func (a *IamAPIService) PostIamOauthDeviceInfo(ctx context.Context) IamAPIPostIamOauthDeviceInfoRequest {
return IamAPIPostIamOauthDeviceInfoRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamOauthDeviceInfoExecute(r IamAPIPostIamOauthDeviceInfoRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamOauthDeviceInfo")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/device/info"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamOauthFederationMfaRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamOauthFederationMfaRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamOauthFederationMfaExecute(r)
}
/*
PostIamOauthFederationMfa Completes a sign-in that came in through another identity provider and still owes a second factor.
Completes a sign-in that came in through another identity
provider and still owes a second factor. The person supplies the factor here
and the login finishes.
The account is fixed when the challenge is issued, not by the request, so no
one can redirect a half-finished login onto somebody else's account. A wrong
factor uses the challenge up: retrying means starting the sign-in again, the
same as a mistyped password.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamOauthFederationMfaRequest
*/
func (a *IamAPIService) PostIamOauthFederationMfa(ctx context.Context) IamAPIPostIamOauthFederationMfaRequest {
return IamAPIPostIamOauthFederationMfaRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamOauthFederationMfaExecute(r IamAPIPostIamOauthFederationMfaRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamOauthFederationMfa")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/federation/mfa"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamOauthIntrospectRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamOauthIntrospectRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamOauthIntrospectExecute(r)
}
/*
PostIamOauthIntrospect Answers whether an access token is still good, and what it is good for — the check a resource server of yours makes before honouring a token it did not mint.
Answers whether an access token is still good, and what it
is good for — the check a resource server of yours makes before honouring a
token it did not mint.
A token counts as active only if it verifies AND has not been revoked, so a
revoked token reads as dead here immediately rather than until it expires. A
token that is unknown, expired or revoked answers simply that it is not
active, and nothing more — the endpoint is not a way to learn about tokens you
were not given.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamOauthIntrospectRequest
*/
func (a *IamAPIService) PostIamOauthIntrospect(ctx context.Context) IamAPIPostIamOauthIntrospectRequest {
return IamAPIPostIamOauthIntrospectRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamOauthIntrospectExecute(r IamAPIPostIamOauthIntrospectRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamOauthIntrospect")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/introspect"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamOauthLogoutRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamOauthLogoutRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamOauthLogoutExecute(r)
}
/*
PostIamOauthLogout Ends a sign-in and sends the browser somewhere sensible.
Ends a sign-in and sends the browser somewhere sensible. Accepts
GET or POST, so it works as a plain link.
It ACTUALLY signs you out — worth stating, because a logout that computes a
redirect and answers {"status":"ok"} while ending no session and revoking no
token is worse than none: the person on the shared machine believes it worked.
Three things happen here, in this order:
1. The browser session dies — sid revoked server-side AND the cookie expired
(sessions.Clear). Server-side revocation is the load-bearing half: a copy
of the cookie taken before logout must not still resolve.
2. The relying party's tokens are revoked when an id_token_hint names it, so
the refresh token cannot mint a fresh access token after the human left.
Revocation state is authoritative — a JWT's `exp` still reads valid for
days, so expiry is necessary but never sufficient.
3. Only then is a redirect considered, and only to a REGISTERED uri.
The open-redirect guard: a redirect happens only when a VERIFIED
id_token_hint (or client_id) identifies the application and that application
has registered the target. Nobody can turn your logout link into a redirect to
a site of their choosing.
A GET is the end-session navigation (OIDC RP-Initiated Logout 1.0 §2), so it
always ends on a page: the registered address when one was asked for, else
this issuer's sign-in page for the application being signed out of. A relying
party therefore needs no configuration to sign someone out. A POST is also how
a program signs out, so it keeps the JSON answer unless it asks for HTML.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamOauthLogoutRequest
*/
func (a *IamAPIService) PostIamOauthLogout(ctx context.Context) IamAPIPostIamOauthLogoutRequest {
return IamAPIPostIamOauthLogoutRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamOauthLogoutExecute(r IamAPIPostIamOauthLogoutRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamOauthLogout")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/logout"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamOauthRefreshTokenRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamOauthRefreshTokenRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamOauthRefreshTokenExecute(r)
}
/*
PostIamOauthRefreshToken Exchanges what your application is holding for the tokens it needs — the one-time code from a finished sign-in, a refresh token, or your own client credentials when the caller is a program rather than a person.
Exchanges what your application is holding for the tokens it
needs — the one-time code from a finished sign-in, a refresh token, or your
own client credentials when the caller is a program rather than a person.
A refresh returns a NEW refresh token and retires the one you sent. If a
retired one is ever presented again the whole chain is revoked, on the
assumption that a token which came back from the dead was copied — so a stolen
refresh token buys an attacker one use and costs them the session.
Responses are never cached, by any hop.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamOauthRefreshTokenRequest
*/
func (a *IamAPIService) PostIamOauthRefreshToken(ctx context.Context) IamAPIPostIamOauthRefreshTokenRequest {
return IamAPIPostIamOauthRefreshTokenRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamOauthRefreshTokenExecute(r IamAPIPostIamOauthRefreshTokenRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamOauthRefreshToken")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/refresh_token"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamOauthRevokeRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamOauthRevokeRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamOauthRevokeExecute(r)
}
/*
PostIamOauthRevoke Retires a token before it expires — what you call when someone signs out or a credential may have leaked.
Retires a token before it expires — what you call when someone
signs out or a credential may have leaked.
Revoking an access token kills that token. Revoking a REFRESH token kills the
whole chain it belongs to, so no further access tokens can be minted from it
and every token already minted from it dies with it.
A token that is not yours, or that never existed, answers success and does
nothing — so the endpoint cannot be used to discover which tokens are real.
PUBLIC clients revoke too, and must: sign-out is the only control a long-lived
refresh token has (RFC 7009 §2.1 — a public client identifies itself with
client_id). A browser app or CLI is a public PKCE client and holds no secret,
and that includes the public half of a registration that keeps a secret for a
backend path, so requiring one here would leave signing out as a local delete —
forgetting a credential that stays spendable for the rest of its lifetime.
Widening authentication does not widen authority. The caller must still POSSESS
the token — and possession already permits USE, of which revocation is the
strict opposite — and the row must belong to the client that presents it. A
caller that did not prove the registration's secret revokes only a grant that
was itself established without it, so a public client_id buys the ability to
destroy exactly what its holder could otherwise spend.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamOauthRevokeRequest
*/
func (a *IamAPIService) PostIamOauthRevoke(ctx context.Context) IamAPIPostIamOauthRevokeRequest {
return IamAPIPostIamOauthRevokeRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamOauthRevokeExecute(r IamAPIPostIamOauthRevokeRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamOauthRevoke")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/revoke"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamOauthTokenRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamOauthTokenRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamOauthTokenExecute(r)
}
/*
PostIamOauthToken Exchanges what your application is holding for the tokens it needs — the one-time code from a finished sign-in, a refresh token, or your own client credentials when the caller is a program rather than a person.
Exchanges what your application is holding for the tokens it
needs — the one-time code from a finished sign-in, a refresh token, or your
own client credentials when the caller is a program rather than a person.
A refresh returns a NEW refresh token and retires the one you sent. If a
retired one is ever presented again the whole chain is revoked, on the
assumption that a token which came back from the dead was copied — so a stolen
refresh token buys an attacker one use and costs them the session.
Responses are never cached, by any hop.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamOauthTokenRequest
*/
func (a *IamAPIService) PostIamOauthToken(ctx context.Context) IamAPIPostIamOauthTokenRequest {
return IamAPIPostIamOauthTokenRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamOauthTokenExecute(r IamAPIPostIamOauthTokenRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamOauthToken")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/token"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamOauthUserinfoRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamOauthUserinfoRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamOauthUserinfoExecute(r)
}
/*
PostIamOauthUserinfo Returns the profile claims for whoever the access token belongs to — the standard OpenID Connect way to find out who is calling you without your application storing anything itself.
Returns the profile claims for whoever the access token
belongs to — the standard OpenID Connect way to find out who is calling you
without your application storing anything itself.
The token must still be live: revoke it and this stops answering.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamOauthUserinfoRequest
*/
func (a *IamAPIService) PostIamOauthUserinfo(ctx context.Context) IamAPIPostIamOauthUserinfoRequest {
return IamAPIPostIamOauthUserinfoRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamOauthUserinfoExecute(r IamAPIPostIamOauthUserinfoRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamOauthUserinfo")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/oauth/userinfo"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamOnboardRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamOnboardRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamOnboardExecute(r)
}
/*
PostIamOnboard Finishes setting up the account of whoever is calling — it creates their organization if they have none and puts them in it, so a person who has just signed up lands somewhere they can work.
Finishes setting up the account of whoever is calling — it
creates their organization if they have none and puts them in it, so a person
who has just signed up lands somewhere they can work.
It always acts on the caller and never on somebody named in the request, so
there is no way to onboard another person's account through it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamOnboardRequest
*/
func (a *IamAPIService) PostIamOnboard(ctx context.Context) IamAPIPostIamOnboardRequest {
return IamAPIPostIamOnboardRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamOnboardExecute(r IamAPIPostIamOnboardRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamOnboard")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/onboard"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamPermissionsRequest struct {
ctx context.Context
ApiService *IamAPIService
iamPermission *IamPermission
}
func (r IamAPIPostIamPermissionsRequest) IamPermission(iamPermission IamPermission) IamAPIPostIamPermissionsRequest {
r.iamPermission = &iamPermission
return r
}
func (r IamAPIPostIamPermissionsRequest) Execute() (*IamPermission, *http.Response, error) {
return r.ApiService.PostIamPermissionsExecute(r)
}
/*
PostIamPermissions Grants a permission — the call that gives a person or a role the ability to do something.
Grants a permission — the call that gives a person or a role the ability to
do something. Adding refuses to overwrite a grant that already exists, so
widening an existing one is an update, never an accident.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamPermissionsRequest
*/
func (a *IamAPIService) PostIamPermissions(ctx context.Context) IamAPIPostIamPermissionsRequest {
return IamAPIPostIamPermissionsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamPermission
func (a *IamAPIService) PostIamPermissionsExecute(r IamAPIPostIamPermissionsRequest) (*IamPermission, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamPermission
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamPermissions")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/permissions"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamPermission == nil {
return localVarReturnValue, nil, reportError("iamPermission 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.iamPermission
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 IamAPIPostIamPreferencesRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamPreferencesRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamPreferencesExecute(r)
}
/*
PostIamPreferences Saves the calling person's own settings and returns the full set afterwards.
Saves the calling person's own settings and returns
the full set afterwards. Send only the settings you are changing — the rest
are kept, so two screens can save at once without one undoing the other.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamPreferencesRequest
*/
func (a *IamAPIService) PostIamPreferences(ctx context.Context) IamAPIPostIamPreferencesRequest {
return IamAPIPostIamPreferencesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamPreferencesExecute(r IamAPIPostIamPreferencesRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamPreferences")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/preferences"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamProjectsRequest struct {
ctx context.Context
ApiService *IamAPIService
iamProjectsInput *IamProjectsInput
}
func (r IamAPIPostIamProjectsRequest) IamProjectsInput(iamProjectsInput IamProjectsInput) IamAPIPostIamProjectsRequest {
r.iamProjectsInput = &iamProjectsInput
return r
}
func (r IamAPIPostIamProjectsRequest) Execute() (*IamProject, *http.Response, error) {
return r.ApiService.PostIamProjectsExecute(r)
}
/*
PostIamProjects Makes a project inside your organization — the scope people pick between when their work is separated by product or client rather than by team.
Makes a project inside your organization — the scope people pick
between when their work is separated by product or client rather than by team.
A name already used in the organization is refused.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamProjectsRequest
*/
func (a *IamAPIService) PostIamProjects(ctx context.Context) IamAPIPostIamProjectsRequest {
return IamAPIPostIamProjectsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamProject
func (a *IamAPIService) PostIamProjectsExecute(r IamAPIPostIamProjectsRequest) (*IamProject, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamProject
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamProjects")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/projects"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamProjectsInput == nil {
return localVarReturnValue, nil, reportError("iamProjectsInput 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.iamProjectsInput
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 IamAPIPostIamRegistryTokenRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamRegistryTokenRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamRegistryTokenExecute(r)
}
/*
PostIamRegistryToken Signs a container client in to your registry.
Signs a container client in to your registry. `docker login`, and every
build tool that pushes or pulls images, lands here: it exchanges the
credential for a short-lived token scoped to exactly the repositories that
credential may touch.
Both of the shapes container tooling uses are accepted, so the same login works
whichever client your pipeline runs.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamRegistryTokenRequest
*/
func (a *IamAPIService) PostIamRegistryToken(ctx context.Context) IamAPIPostIamRegistryTokenRequest {
return IamAPIPostIamRegistryTokenRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamRegistryTokenExecute(r IamAPIPostIamRegistryTokenRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamRegistryToken")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/registry/token"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamRolesRequest struct {
ctx context.Context
ApiService *IamAPIService
iamInput *IamInput
}
func (r IamAPIPostIamRolesRequest) IamInput(iamInput IamInput) IamAPIPostIamRolesRequest {
r.iamInput = &iamInput
return r
}
func (r IamAPIPostIamRolesRequest) Execute() (*IamRole, *http.Response, error) {
return r.ApiService.PostIamRolesExecute(r)
}
/*
PostIamRoles Makes a role — a named group of people that permissions are granted to.
Makes a role — a named group of people that permissions are granted to.
Granting to a role rather than to each person is what keeps access correct as
your team changes: add someone to the role and they inherit everything it can
do. A name already used in your organization is refused.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamRolesRequest
*/
func (a *IamAPIService) PostIamRoles(ctx context.Context) IamAPIPostIamRolesRequest {
return IamAPIPostIamRolesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamRole
func (a *IamAPIService) PostIamRolesExecute(r IamAPIPostIamRolesRequest) (*IamRole, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamRole
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamRoles")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/roles"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamInput == nil {
return localVarReturnValue, nil, reportError("iamInput 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.iamInput
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 IamAPIPostIamScimV2UsersRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamScimV2UsersRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamScimV2UsersExecute(r)
}
/*
PostIamScimV2Users Provisions a person from your identity provider — how a new hire gets an account here automatically when they are added over there.
Provisions a person from your identity provider — how a new hire
gets an account here automatically when they are added over there.
Takes an administrator. Making someone an administrator takes more than that,
so an IdP integration cannot escalate anyone by setting a flag.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamScimV2UsersRequest
*/
func (a *IamAPIService) PostIamScimV2Users(ctx context.Context) IamAPIPostIamScimV2UsersRequest {
return IamAPIPostIamScimV2UsersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamScimV2UsersExecute(r IamAPIPostIamScimV2UsersRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamScimV2Users")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/scim/v2/Users"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamServiceAccountsRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamServiceAccountsRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamServiceAccountsExecute(r)
}
/*
PostIamServiceAccounts Makes a service account — an identity for a program rather than a person, for a script, a bot or a deployment that has to authenticate on its own.
Makes a service account — an identity for a program rather than a
person, for a script, a bot or a deployment that has to authenticate on its
own.
It comes back with its first key, and the secret half is shown ONCE, here.
There is no way to read it again; if you lose it, rotate.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamServiceAccountsRequest
*/
func (a *IamAPIService) PostIamServiceAccounts(ctx context.Context) IamAPIPostIamServiceAccountsRequest {
return IamAPIPostIamServiceAccountsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamServiceAccountsExecute(r IamAPIPostIamServiceAccountsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamServiceAccounts")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/service-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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamServiceAccountsByNameKeysRequest struct {
ctx context.Context
ApiService *IamAPIService
name string
}
func (r IamAPIPostIamServiceAccountsByNameKeysRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamServiceAccountsByNameKeysExecute(r)
}
/*
PostIamServiceAccountsByNameKeys Serves POST /v1/iam/service-accounts/:name/keys: mint a fresh key, invalidating the prior one, and return the new raw secret exactly once.
Serves POST /v1/iam/service-accounts/:name/keys: mint a fresh key,
invalidating the prior one, and return the new raw secret exactly once.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name
@return IamAPIPostIamServiceAccountsByNameKeysRequest
*/
func (a *IamAPIService) PostIamServiceAccountsByNameKeys(ctx context.Context, name string) IamAPIPostIamServiceAccountsByNameKeysRequest {
return IamAPIPostIamServiceAccountsByNameKeysRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamServiceAccountsByNameKeysExecute(r IamAPIPostIamServiceAccountsByNameKeysRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamServiceAccountsByNameKeys")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/service-accounts/{name}/keys"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamSigninRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamSigninRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamSigninExecute(r)
}
/*
PostIamSignin Completes a sign-in: it exchanges the one-time code your application was handed at the end of the login flow for a live session, and returns the signed-in account.
Completes a sign-in: it exchanges the one-time code your
application was handed at the end of the login flow for a live session, and
returns the signed-in account.
The code works once. This is the call that turns a finished login into
something your application can act on.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamSigninRequest
*/
func (a *IamAPIService) PostIamSignin(ctx context.Context) IamAPIPostIamSigninRequest {
return IamAPIPostIamSigninRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamSigninExecute(r IamAPIPostIamSigninRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamSignin")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/signin"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamSignupRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamSignupRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamSignupExecute(r)
}
/*
PostIamSignup Creates an account from the sign-up form and applies the application's own sign-up rules — whether self-service registration is open at all, and which fields it requires.
Creates an account from the sign-up form and applies the
application's own sign-up rules — whether self-service registration is open at
all, and which fields it requires.
The password is hashed before it is stored and is never returned.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamSignupRequest
*/
func (a *IamAPIService) PostIamSignup(ctx context.Context) IamAPIPostIamSignupRequest {
return IamAPIPostIamSignupRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamSignupExecute(r IamAPIPostIamSignupRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamSignup")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/signup"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamTeamsRequest struct {
ctx context.Context
ApiService *IamAPIService
iamTeamsInput *IamTeamsInput
}
func (r IamAPIPostIamTeamsRequest) IamTeamsInput(iamTeamsInput IamTeamsInput) IamAPIPostIamTeamsRequest {
r.iamTeamsInput = &iamTeamsInput
return r
}
func (r IamAPIPostIamTeamsRequest) Execute() (*IamTeam, *http.Response, error) {
return r.ApiService.PostIamTeamsExecute(r)
}
/*
PostIamTeams Makes a team — a named set of people that roles and permissions grant to.
Makes a team — a named set of people that roles and permissions grant
to. Granting to a team rather than to each person keeps access correct as
people come and go: add someone and they inherit what the team can do. A name
already used in your organization is refused.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamTeamsRequest
*/
func (a *IamAPIService) PostIamTeams(ctx context.Context) IamAPIPostIamTeamsRequest {
return IamAPIPostIamTeamsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamTeam
func (a *IamAPIService) PostIamTeamsExecute(r IamAPIPostIamTeamsRequest) (*IamTeam, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamTeam
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamTeams")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/teams"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamTeamsInput == nil {
return localVarReturnValue, nil, reportError("iamTeamsInput 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.iamTeamsInput
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 IamAPIPostIamTokensIssueRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamTokensIssueRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamTokensIssueExecute(r)
}
/*
PostIamTokensIssue Mints an access token for the `?id=<owner>/<name>` target user (optional `?aud=` resource, RFC 8707), issued by the authenticated + allow-listed confidential client.
Mints an access token for the `?id=<owner>/<name>` target
user (optional `?aud=` resource, RFC 8707), issued by the authenticated +
allow-listed confidential client. The token's subject + owner are the TARGET
USER's, so a resource server scopes on the validated owner claim to the user's
tenant — indistinguishable from a token the user obtained directly. Response is
the camelCase `{accessToken, expiresIn}` body identity.ts consumes. Equivalent to
the RFC 8693 token-exchange grant, minus the subject_token proof (the console has
the user's id, not a token) — the reason this compat shim exists.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamTokensIssueRequest
*/
func (a *IamAPIService) PostIamTokensIssue(ctx context.Context) IamAPIPostIamTokensIssueRequest {
return IamAPIPostIamTokensIssueRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamTokensIssueExecute(r IamAPIPostIamTokensIssueRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamTokensIssue")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/tokens/issue"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamUnlinkRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamUnlinkRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamUnlinkExecute(r)
}
/*
PostIamUnlink Disconnects one sign-in identity from an account, so that provider can no longer be used to sign in as that person.
Disconnects one sign-in identity from an account, so that provider can
no longer be used to sign in as that person. Their account and every other way
they sign in are untouched. Two principals may do it, and
only two: the account holder itself, and a SuperAdmin (schema.User.SuperAdmin,
asked of the caller's own row). An ORG ADMIN deliberately may NOT — unlinking
is not tenant administration, it is unpicking someone's own sign-in method, so
the generic org-admin rule is the wrong answer here. A SuperAdmin unlinking
someone else's method is recorded on the SuperAdmin trail.
A holder unlinking itself must also be permitted by the application — the
provider link's CanUnlink flag — so an organization that mandates federated
sign-in cannot have its users strand themselves. A SuperAdmin is not bound by
that flag; it is the platform's own recovery path. Fail-closed throughout.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamUnlinkRequest
*/
func (a *IamAPIService) PostIamUnlink(ctx context.Context) IamAPIPostIamUnlinkRequest {
return IamAPIPostIamUnlinkRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamUnlinkExecute(r IamAPIPostIamUnlinkRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamUnlink")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/unlink"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamUsersRequest struct {
ctx context.Context
ApiService *IamAPIService
iamCreateInput *IamCreateInput
}
func (r IamAPIPostIamUsersRequest) IamCreateInput(iamCreateInput IamCreateInput) IamAPIPostIamUsersRequest {
r.iamCreateInput = &iamCreateInput
return r
}
func (r IamAPIPostIamUsersRequest) Execute() (*IamUser, *http.Response, error) {
return r.ApiService.PostIamUsersExecute(r)
}
/*
PostIamUsers Adds a person to your organization.
Adds a person to your organization. Send a password and it becomes the
one they sign in with; it is hashed before it is stored and never comes back
in any response.
The username is checked against the same rule every account in the Hanzo Cloud
is held to, whichever way it was created — this call, password signup, a social
sign-in, or SCIM — so a name accepted here works everywhere.
A name already taken in your organization is refused rather than overwritten.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamUsersRequest
*/
func (a *IamAPIService) PostIamUsers(ctx context.Context) IamAPIPostIamUsersRequest {
return IamAPIPostIamUsersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamUser
func (a *IamAPIService) PostIamUsersExecute(r IamAPIPostIamUsersRequest) (*IamUser, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamUser
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamUsers")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/users"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamCreateInput == nil {
return localVarReturnValue, nil, reportError("iamCreateInput 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.iamCreateInput
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 IamAPIPostIamUsersByOwnerByNameKeysRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIPostIamUsersByOwnerByNameKeysRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamUsersByOwnerByNameKeysExecute(r)
}
/*
PostIamUsersByOwnerByNameKeys (re)generates the target user's key of the requested TYPE and returns it once, over the shared authorizeMinter + mintTarget seam.
(re)generates the target user's key of the requested TYPE and
returns it once, over the shared authorizeMinter + mintTarget seam. `?type=secret`
(the default) yields the confidential sk-; `?type=publishable` yields the pk- that
is safe to ship in client JS and resolves to an org, never a principal.
It writes the schema.Key row that the resolvers actually read. schema.User.AccessKey
is not a credential and nothing resolves it, so a key stamped there would
authenticate nobody.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIPostIamUsersByOwnerByNameKeysRequest
*/
func (a *IamAPIService) PostIamUsersByOwnerByNameKeys(ctx context.Context, owner string, name string) IamAPIPostIamUsersByOwnerByNameKeysRequest {
return IamAPIPostIamUsersByOwnerByNameKeysRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamUsersByOwnerByNameKeysExecute(r IamAPIPostIamUsersByOwnerByNameKeysRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamUsersByOwnerByNameKeys")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/users/{owner}/{name}/keys"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamVerificationCodesRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamVerificationCodesRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamVerificationCodesExecute(r)
}
/*
PostIamVerificationCodes Validates the request and asks otp to get a code to the person.
Validates the request and asks otp to get a code to the
person. The request fields are read via fiber's FormValue — the escape hatch zip
exposes for form bodies (multipart or urlencoded) — since the typed JSON Bind does
not apply here. v1 also accepts countryCode/method/checkUser/captchaType; iam
ignores them (the captcha/forget/MFA flows those drive are not ported), and
CAPTCHA verification is likewise not enforced — iam models no captcha provider —
so the code is issued once the destination and application validate.
An email is the designed sign-in mail, a link beside the code and from the
application's org as its reader knows it (otp.IssueLink), when the request's
Origin is the origin of one of the application's redirect URIs ([Landing]);
otherwise it is the code alone.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamVerificationCodesRequest
*/
func (a *IamAPIService) PostIamVerificationCodes(ctx context.Context) IamAPIPostIamVerificationCodesRequest {
return IamAPIPostIamVerificationCodesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamVerificationCodesExecute(r IamAPIPostIamVerificationCodesRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamVerificationCodes")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/verification-codes"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamWeb3VerifyRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamWeb3VerifyRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamWeb3VerifyExecute(r)
}
/*
PostIamWeb3Verify Completes a wallet sign-in: it verifies the signed challenge and, if it holds, signs the wallet's owner in.
Completes a wallet sign-in: it verifies the signed challenge and, if it
holds, signs the wallet's owner in.
This IS the login — it answers exactly as a password sign-in does, so the rest
of your flow does not branch on how somebody arrived.
A wallet no account holds yet creates one, and one address or one network
creates only so many in a window, a day by default. Past that the answer is
429 with Retry-After and code wallet_signup_capped; data names the bound ("ip"
or "subnet"), its limit, and its window in seconds. A wallet already on file
is never counted.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamWeb3VerifyRequest
*/
func (a *IamAPIService) PostIamWeb3Verify(ctx context.Context) IamAPIPostIamWeb3VerifyRequest {
return IamAPIPostIamWeb3VerifyRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamWeb3VerifyExecute(r IamAPIPostIamWeb3VerifyRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamWeb3Verify")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/web3/verify"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamWebauthnSigninFinishRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamWebauthnSigninFinishRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamWebauthnSigninFinishExecute(r)
}
/*
PostIamWebauthnSigninFinish Verifies the signed challenge and signs the person in.
Verifies the signed challenge and signs the person in.
It answers exactly as a password sign-in does — the same envelope, through the
same grant — so nothing downstream branches on how somebody arrived.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamWebauthnSigninFinishRequest
*/
func (a *IamAPIService) PostIamWebauthnSigninFinish(ctx context.Context) IamAPIPostIamWebauthnSigninFinishRequest {
return IamAPIPostIamWebauthnSigninFinishRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamWebauthnSigninFinishExecute(r IamAPIPostIamWebauthnSigninFinishRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamWebauthnSigninFinish")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/webauthn/signin/finish"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamWebauthnSignupFinishRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPostIamWebauthnSignupFinishRequest) Execute() (*http.Response, error) {
return r.ApiService.PostIamWebauthnSignupFinishExecute(r)
}
/*
PostIamWebauthnSignupFinish Verifies the newly created passkey and stores it, so the person can sign in with their device from then on.
Verifies the newly created passkey and stores it, so the person
can sign in with their device from then on.
Only this site's own pages may finish an enrollment, and only as JSON.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamWebauthnSignupFinishRequest
*/
func (a *IamAPIService) PostIamWebauthnSignupFinish(ctx context.Context) IamAPIPostIamWebauthnSignupFinishRequest {
return IamAPIPostIamWebauthnSignupFinishRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PostIamWebauthnSignupFinishExecute(r IamAPIPostIamWebauthnSignupFinishRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamWebauthnSignupFinish")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/webauthn/signup/finish"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPostIamWorkspacesRequest struct {
ctx context.Context
ApiService *IamAPIService
iamWorkspacesInput *IamWorkspacesInput
}
func (r IamAPIPostIamWorkspacesRequest) IamWorkspacesInput(iamWorkspacesInput IamWorkspacesInput) IamAPIPostIamWorkspacesRequest {
r.iamWorkspacesInput = &iamWorkspacesInput
return r
}
func (r IamAPIPostIamWorkspacesRequest) Execute() (*IamWorkspace, *http.Response, error) {
return r.ApiService.PostIamWorkspacesExecute(r)
}
/*
PostIamWorkspaces Makes a workspace inside your organization — the scope a team works in, alongside projects rather than instead of them.
Makes a workspace inside your organization — the scope a team works in,
alongside projects rather than instead of them. A name already used in the
organization is refused.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPostIamWorkspacesRequest
*/
func (a *IamAPIService) PostIamWorkspaces(ctx context.Context) IamAPIPostIamWorkspacesRequest {
return IamAPIPostIamWorkspacesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamWorkspace
func (a *IamAPIService) PostIamWorkspacesExecute(r IamAPIPostIamWorkspacesRequest) (*IamWorkspace, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamWorkspace
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PostIamWorkspaces")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/workspaces"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamWorkspacesInput == nil {
return localVarReturnValue, nil, reportError("iamWorkspacesInput 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.iamWorkspacesInput
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 IamAPIPutIamAccountRequest struct {
ctx context.Context
ApiService *IamAPIService
iamAccountBody *IamAccountBody
cookie *string
authorization *string
secFetchSite *string
origin *string
host *string
contentType *string
}
func (r IamAPIPutIamAccountRequest) IamAccountBody(iamAccountBody IamAccountBody) IamAPIPutIamAccountRequest {
r.iamAccountBody = &iamAccountBody
return r
}
func (r IamAPIPutIamAccountRequest) Cookie(cookie string) IamAPIPutIamAccountRequest {
r.cookie = &cookie
return r
}
func (r IamAPIPutIamAccountRequest) Authorization(authorization string) IamAPIPutIamAccountRequest {
r.authorization = &authorization
return r
}
func (r IamAPIPutIamAccountRequest) SecFetchSite(secFetchSite string) IamAPIPutIamAccountRequest {
r.secFetchSite = &secFetchSite
return r
}
func (r IamAPIPutIamAccountRequest) Origin(origin string) IamAPIPutIamAccountRequest {
r.origin = &origin
return r
}
func (r IamAPIPutIamAccountRequest) Host(host string) IamAPIPutIamAccountRequest {
r.host = &host
return r
}
func (r IamAPIPutIamAccountRequest) ContentType(contentType string) IamAPIPutIamAccountRequest {
r.contentType = &contentType
return r
}
func (r IamAPIPutIamAccountRequest) Execute() (*IamAnswer, *http.Response, error) {
return r.ApiService.PutIamAccountExecute(r)
}
/*
PutIamAccount Saves the calling person's own profile — the name they are shown by, their picture, a line about themselves and a link.
Saves the calling person's own profile — the name they are
shown by, their picture, a line about themselves and a link.
Only their own: the request names nobody, so it cannot reach another account.
Send only what you are changing; a field you leave out keeps the value it had,
and a field you send empty is cleared.
A picture is an https link or an inline image up to 96 KiB, the same value an
organization's mark is (schema.AvatarRef) — one rule for how a subject appears,
whether the subject is a person or an organization.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPutIamAccountRequest
*/
func (a *IamAPIService) PutIamAccount(ctx context.Context) IamAPIPutIamAccountRequest {
return IamAPIPutIamAccountRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamAnswer
func (a *IamAPIService) PutIamAccountExecute(r IamAPIPutIamAccountRequest) (*IamAnswer, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAnswer
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamAccount")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/account"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamAccountBody == nil {
return localVarReturnValue, nil, reportError("iamAccountBody 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
}
if r.cookie != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Cookie", r.cookie, "simple", "")
}
if r.authorization != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
}
if r.secFetchSite != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Sec-Fetch-Site", r.secFetchSite, "simple", "")
}
if r.origin != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Origin", r.origin, "simple", "")
}
if r.host != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Host", r.host, "simple", "")
}
if r.contentType != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Content-Type", r.contentType, "simple", "")
}
// body params
localVarPostBody = r.iamAccountBody
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,
}
if localVarHTTPResponse.StatusCode == 400 {
var v IamAnswer
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
}
if localVarHTTPResponse.StatusCode == 403 {
var v IamAnswer
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
}
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 IamAPIPutIamAddressRequest struct {
ctx context.Context
ApiService *IamAPIService
iamAddressBody *IamAddressBody
cookie *string
authorization *string
secFetchSite *string
origin *string
host *string
contentType *string
}
func (r IamAPIPutIamAddressRequest) IamAddressBody(iamAddressBody IamAddressBody) IamAPIPutIamAddressRequest {
r.iamAddressBody = &iamAddressBody
return r
}
func (r IamAPIPutIamAddressRequest) Cookie(cookie string) IamAPIPutIamAddressRequest {
r.cookie = &cookie
return r
}
func (r IamAPIPutIamAddressRequest) Authorization(authorization string) IamAPIPutIamAddressRequest {
r.authorization = &authorization
return r
}
func (r IamAPIPutIamAddressRequest) SecFetchSite(secFetchSite string) IamAPIPutIamAddressRequest {
r.secFetchSite = &secFetchSite
return r
}
func (r IamAPIPutIamAddressRequest) Origin(origin string) IamAPIPutIamAddressRequest {
r.origin = &origin
return r
}
func (r IamAPIPutIamAddressRequest) Host(host string) IamAPIPutIamAddressRequest {
r.host = &host
return r
}
func (r IamAPIPutIamAddressRequest) ContentType(contentType string) IamAPIPutIamAddressRequest {
r.contentType = &contentType
return r
}
func (r IamAPIPutIamAddressRequest) Execute() (*IamAnswer, *http.Response, error) {
return r.ApiService.PutIamAddressExecute(r)
}
/*
PutIamAddress Adds an email address or a phone number to the calling person's own account, so they can sign in with it — by a code sent there, or to recover a password.
Adds an email address or a phone number to the calling
person's own account, so they can sign in with it — by a code sent there, or
to recover a password.
First ask POST /v1/iam/verification-codes to send a code to the new address,
with the applicationId of the application you sign in at, then send that
application's clientId, the address and the code here. Only the caller's own
account is written; the request names nobody.
It adds and never replaces: an account that already has an email keeps it, and
asking again with the same address answers ok. An address another account at
that application already signs in with is refused with the same words a wrong
code gets.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPutIamAddressRequest
*/
func (a *IamAPIService) PutIamAddress(ctx context.Context) IamAPIPutIamAddressRequest {
return IamAPIPutIamAddressRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamAnswer
func (a *IamAPIService) PutIamAddressExecute(r IamAPIPutIamAddressRequest) (*IamAnswer, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAnswer
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamAddress")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/address"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamAddressBody == nil {
return localVarReturnValue, nil, reportError("iamAddressBody 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
}
if r.cookie != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Cookie", r.cookie, "simple", "")
}
if r.authorization != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
}
if r.secFetchSite != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Sec-Fetch-Site", r.secFetchSite, "simple", "")
}
if r.origin != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Origin", r.origin, "simple", "")
}
if r.host != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Host", r.host, "simple", "")
}
if r.contentType != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Content-Type", r.contentType, "simple", "")
}
// body params
localVarPostBody = r.iamAddressBody
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,
}
if localVarHTTPResponse.StatusCode == 400 {
var v IamAnswer
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
}
if localVarHTTPResponse.StatusCode == 403 {
var v IamAnswer
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
}
if localVarHTTPResponse.StatusCode == 409 {
var v IamAnswer
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
}
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 IamAPIPutIamApplicationsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamApplication *IamApplication
}
func (r IamAPIPutIamApplicationsByOwnerByNameRequest) IamApplication(iamApplication IamApplication) IamAPIPutIamApplicationsByOwnerByNameRequest {
r.iamApplication = &iamApplication
return r
}
func (r IamAPIPutIamApplicationsByOwnerByNameRequest) Execute() (*IamApplication, *http.Response, error) {
return r.ApiService.PutIamApplicationsByOwnerByNameExecute(r)
}
/*
PutIamApplicationsByOwnerByName Changes an application's display, its sign-in methods and the redirect URIs it may return to — the call that makes login work from a new host.
Changes an application's display, its sign-in methods and the redirect
URIs it may return to — the call that makes login work from a new host. Which
organization it belongs to and what it is named are fixed when it is created
and are not editable here. An application that serves other organizations —
isShared, or any orgChoiceMode but "" and "None" — is written by a SuperAdmin
only, before and after the change.
Exported so the legacy update-application alias reuses this exact path — one
update, two spellings.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIPutIamApplicationsByOwnerByNameRequest
*/
func (a *IamAPIService) PutIamApplicationsByOwnerByName(ctx context.Context, owner string, name string) IamAPIPutIamApplicationsByOwnerByNameRequest {
return IamAPIPutIamApplicationsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamApplication
func (a *IamAPIService) PutIamApplicationsByOwnerByNameExecute(r IamAPIPutIamApplicationsByOwnerByNameRequest) (*IamApplication, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamApplication
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamApplicationsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/applications/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamApplication == nil {
return localVarReturnValue, nil, reportError("iamApplication 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.iamApplication
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 IamAPIPutIamAuditLogsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamAuditlogsInput *IamAuditlogsInput
}
func (r IamAPIPutIamAuditLogsByOwnerByNameRequest) IamAuditlogsInput(iamAuditlogsInput IamAuditlogsInput) IamAPIPutIamAuditLogsByOwnerByNameRequest {
r.iamAuditlogsInput = &iamAuditlogsInput
return r
}
func (r IamAPIPutIamAuditLogsByOwnerByNameRequest) Execute() (*IamAuditLog, *http.Response, error) {
return r.ApiService.PutIamAuditLogsByOwnerByNameExecute(r)
}
/*
PutIamAuditLogsByOwnerByName Corrects an audit entry.
Corrects an audit entry. The trail is append-only in normal operation
and nothing in the Hanzo Cloud rewrites it — this exists for an administrator
to correct an entry their own systems recorded wrongly.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIPutIamAuditLogsByOwnerByNameRequest
*/
func (a *IamAPIService) PutIamAuditLogsByOwnerByName(ctx context.Context, owner string, name string) IamAPIPutIamAuditLogsByOwnerByNameRequest {
return IamAPIPutIamAuditLogsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamAuditLog
func (a *IamAPIService) PutIamAuditLogsByOwnerByNameExecute(r IamAPIPutIamAuditLogsByOwnerByNameRequest) (*IamAuditLog, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAuditLog
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamAuditLogsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/audit-logs/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamAuditlogsInput == nil {
return localVarReturnValue, nil, reportError("iamAuditlogsInput 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.iamAuditlogsInput
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 IamAPIPutIamCertsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamCert *IamCert
}
func (r IamAPIPutIamCertsByOwnerByNameRequest) IamCert(iamCert IamCert) IamAPIPutIamCertsByOwnerByNameRequest {
r.iamCert = &iamCert
return r
}
func (r IamAPIPutIamCertsByOwnerByNameRequest) Execute() (*IamCert, *http.Response, error) {
return r.ApiService.PutIamCertsByOwnerByNameExecute(r)
}
/*
PutIamCertsByOwnerByName Changes a signing certificate's settings.
Changes a signing certificate's settings. What it is called does not
change, and neither does when it was added.
A PUT here is a METADATA edit — display name, expiry, provider. It overlays
only the fields the request actually SET onto the loaded row: a field the JSON
omits (or leaves at its zero value) keeps what the row holds, rather than
blanking it. That is load-bearing, not a nicety. A read serves the public
Certificate (Mask hides only PrivateKey and AccessSecret), so a client that
reads a cert, changes one field, and writes it back sends the masked halves
empty and every other field it did not touch at its zero value — and the old
full-struct overlay wrote all of those blanks back. Blanking CryptoAlgorithm
alone drops the cert from the JWKS (oidc.Publishes turns false), so every
token under its `kid` stops verifying; blanking Provider/Account/ExpireTime
breaks ACME renewal and expiry — all from a request that only meant to rename
it. Absent-or-zero means "unchanged", so the deployment (key) and a rotation
(cert) remain the only way key or published material changes; the metadata API
cannot clear it.
The overlay is generic — it copies every set field, so a field nobody has added
yet is carried without a line here — and leaves three things the request may
not move: the bound Model (id, createdAt, key, snapshot), the natural key
(owner/name address the row, they do not mutate it), and the creation stamp.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIPutIamCertsByOwnerByNameRequest
*/
func (a *IamAPIService) PutIamCertsByOwnerByName(ctx context.Context, owner string, name string) IamAPIPutIamCertsByOwnerByNameRequest {
return IamAPIPutIamCertsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamCert
func (a *IamAPIService) PutIamCertsByOwnerByNameExecute(r IamAPIPutIamCertsByOwnerByNameRequest) (*IamCert, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamCert
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamCertsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/certs/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamCert == nil {
return localVarReturnValue, nil, reportError("iamCert 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.iamCert
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 IamAPIPutIamConsentRequest struct {
ctx context.Context
ApiService *IamAPIService
}
func (r IamAPIPutIamConsentRequest) Execute() (*http.Response, error) {
return r.ApiService.PutIamConsentExecute(r)
}
/*
PutIamConsent Records the calling person's privacy and communication choices.
Records the calling person's privacy and communication
choices. Only their own — there is no way to set consent for somebody else.
Send only the answers you are changing. A question you leave out keeps the
answer it already had, so a screen that saves one switch never revokes the
other, and two screens saving at once do not undo each other.
An answer this version does not recognize is refused here rather than stored,
so nothing is ever persisted for a later reader to have to interpret.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPutIamConsentRequest
*/
func (a *IamAPIService) PutIamConsent(ctx context.Context) IamAPIPutIamConsentRequest {
return IamAPIPutIamConsentRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *IamAPIService) PutIamConsentExecute(r IamAPIPutIamConsentRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamConsent")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/consent"
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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPutIamInvitationsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamInvitationsInput *IamInvitationsInput
}
func (r IamAPIPutIamInvitationsByOwnerByNameRequest) IamInvitationsInput(iamInvitationsInput IamInvitationsInput) IamAPIPutIamInvitationsByOwnerByNameRequest {
r.iamInvitationsInput = &iamInvitationsInput
return r
}
func (r IamAPIPutIamInvitationsByOwnerByNameRequest) Execute() (*IamInvitation, *http.Response, error) {
return r.ApiService.PutIamInvitationsByOwnerByNameExecute(r)
}
/*
PutIamInvitationsByOwnerByName Changes an invitation's terms — the role it grants, how many may redeem it, or when it expires.
Changes an invitation's terms — the role it grants, how many may redeem
it, or when it expires. What it is called does not change.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIPutIamInvitationsByOwnerByNameRequest
*/
func (a *IamAPIService) PutIamInvitationsByOwnerByName(ctx context.Context, owner string, name string) IamAPIPutIamInvitationsByOwnerByNameRequest {
return IamAPIPutIamInvitationsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamInvitation
func (a *IamAPIService) PutIamInvitationsByOwnerByNameExecute(r IamAPIPutIamInvitationsByOwnerByNameRequest) (*IamInvitation, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamInvitation
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamInvitationsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/invitations/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamInvitationsInput == nil {
return localVarReturnValue, nil, reportError("iamInvitationsInput 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.iamInvitationsInput
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 IamAPIPutIamKeysByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamKey *IamKey
}
func (r IamAPIPutIamKeysByOwnerByNameRequest) IamKey(iamKey IamKey) IamAPIPutIamKeysByOwnerByNameRequest {
r.iamKey = &iamKey
return r
}
func (r IamAPIPutIamKeysByOwnerByNameRequest) Execute() (*IamKey, *http.Response, error) {
return r.ApiService.PutIamKeysByOwnerByNameExecute(r)
}
/*
PutIamKeysByOwnerByName Changes what a key is called, what it may reach, when it expires, or revokes it.
Changes what a key is called, what it may reach, when it expires, or
revokes it. The credential itself is not reissued — the key in your deployment
keeps working until it expires or is revoked.
An update writes the whole set of editable fields, so send the key as you read
it with your changes made. The class in its scope (publishable or secret) is
fixed at creation and an update naming the other is refused. Setting state to
"Revoked" revokes the key: the row stays, records who revoked it and when, and
is never updated again.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner Owner is the tenant that holds the key; Name is unique within Owner.
@param name
@return IamAPIPutIamKeysByOwnerByNameRequest
*/
func (a *IamAPIService) PutIamKeysByOwnerByName(ctx context.Context, owner string, name string) IamAPIPutIamKeysByOwnerByNameRequest {
return IamAPIPutIamKeysByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamKey
func (a *IamAPIService) PutIamKeysByOwnerByNameExecute(r IamAPIPutIamKeysByOwnerByNameRequest) (*IamKey, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamKey
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamKeysByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/keys/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamKey == nil {
return localVarReturnValue, nil, reportError("iamKey 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.iamKey
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 IamAPIPutIamPasswordRequest struct {
ctx context.Context
ApiService *IamAPIService
iamPasswordBody *IamPasswordBody
cookie *string
authorization *string
secFetchSite *string
origin *string
host *string
contentType *string
}
func (r IamAPIPutIamPasswordRequest) IamPasswordBody(iamPasswordBody IamPasswordBody) IamAPIPutIamPasswordRequest {
r.iamPasswordBody = &iamPasswordBody
return r
}
func (r IamAPIPutIamPasswordRequest) Cookie(cookie string) IamAPIPutIamPasswordRequest {
r.cookie = &cookie
return r
}
func (r IamAPIPutIamPasswordRequest) Authorization(authorization string) IamAPIPutIamPasswordRequest {
r.authorization = &authorization
return r
}
func (r IamAPIPutIamPasswordRequest) SecFetchSite(secFetchSite string) IamAPIPutIamPasswordRequest {
r.secFetchSite = &secFetchSite
return r
}
func (r IamAPIPutIamPasswordRequest) Origin(origin string) IamAPIPutIamPasswordRequest {
r.origin = &origin
return r
}
func (r IamAPIPutIamPasswordRequest) Host(host string) IamAPIPutIamPasswordRequest {
r.host = &host
return r
}
func (r IamAPIPutIamPasswordRequest) ContentType(contentType string) IamAPIPutIamPasswordRequest {
r.contentType = &contentType
return r
}
func (r IamAPIPutIamPasswordRequest) Execute() (*IamAnswer, *http.Response, error) {
return r.ApiService.PutIamPasswordExecute(r)
}
/*
PutIamPassword Replaces the calling person's password.
Replaces the calling person's password. Only their own —
there is no shape of this request that writes somebody else's.
Prove who you are with the password you are replacing, or — when you cannot
sign in at all — with a code sent to the address the account already holds.
Exactly one of the two: a request carrying both proves nothing more than
either, and answering it would mean deciding which one mattered.
A reset also clears the account lockout, in the SAME transaction as the
digest. Replacing a credential retires the run of guesses against the old one,
and without this a person who reset a forgotten password was still refused for
up to fifteen more minutes — with the brand-new password they had just chosen.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPutIamPasswordRequest
*/
func (a *IamAPIService) PutIamPassword(ctx context.Context) IamAPIPutIamPasswordRequest {
return IamAPIPutIamPasswordRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamAnswer
func (a *IamAPIService) PutIamPasswordExecute(r IamAPIPutIamPasswordRequest) (*IamAnswer, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAnswer
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamPassword")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/password"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamPasswordBody == nil {
return localVarReturnValue, nil, reportError("iamPasswordBody 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
}
if r.cookie != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Cookie", r.cookie, "simple", "")
}
if r.authorization != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
}
if r.secFetchSite != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Sec-Fetch-Site", r.secFetchSite, "simple", "")
}
if r.origin != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Origin", r.origin, "simple", "")
}
if r.host != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Host", r.host, "simple", "")
}
if r.contentType != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Content-Type", r.contentType, "simple", "")
}
// body params
localVarPostBody = r.iamPasswordBody
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,
}
if localVarHTTPResponse.StatusCode == 400 {
var v IamAnswer
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
}
if localVarHTTPResponse.StatusCode == 403 {
var v IamAnswer
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
}
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 IamAPIPutIamPermissionsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamPermission *IamPermission
}
func (r IamAPIPutIamPermissionsByOwnerByNameRequest) IamPermission(iamPermission IamPermission) IamAPIPutIamPermissionsByOwnerByNameRequest {
r.iamPermission = &iamPermission
return r
}
func (r IamAPIPutIamPermissionsByOwnerByNameRequest) Execute() (*IamPermission, *http.Response, error) {
return r.ApiService.PutIamPermissionsByOwnerByNameExecute(r)
}
/*
PutIamPermissionsByOwnerByName Changes who a permission grants to, what it allows, or the resources it covers.
Changes who a permission grants to, what it allows, or the resources it
covers. Access changes as soon as the write lands. What the permission is
called does not change, and neither does when it was created.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner Identity — the (owner, name) natural key.
@param name
@return IamAPIPutIamPermissionsByOwnerByNameRequest
*/
func (a *IamAPIService) PutIamPermissionsByOwnerByName(ctx context.Context, owner string, name string) IamAPIPutIamPermissionsByOwnerByNameRequest {
return IamAPIPutIamPermissionsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamPermission
func (a *IamAPIService) PutIamPermissionsByOwnerByNameExecute(r IamAPIPutIamPermissionsByOwnerByNameRequest) (*IamPermission, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamPermission
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamPermissionsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/permissions/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamPermission == nil {
return localVarReturnValue, nil, reportError("iamPermission 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.iamPermission
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 IamAPIPutIamProjectsByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamProjectsInput *IamProjectsInput
}
func (r IamAPIPutIamProjectsByOwnerByNameRequest) IamProjectsInput(iamProjectsInput IamProjectsInput) IamAPIPutIamProjectsByOwnerByNameRequest {
r.iamProjectsInput = &iamProjectsInput
return r
}
func (r IamAPIPutIamProjectsByOwnerByNameRequest) Execute() (*IamProject, *http.Response, error) {
return r.ApiService.PutIamProjectsByOwnerByNameExecute(r)
}
/*
PutIamProjectsByOwnerByName Changes a project's settings.
Changes a project's settings. What it is called does not change, and
neither does when it was created.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIPutIamProjectsByOwnerByNameRequest
*/
func (a *IamAPIService) PutIamProjectsByOwnerByName(ctx context.Context, owner string, name string) IamAPIPutIamProjectsByOwnerByNameRequest {
return IamAPIPutIamProjectsByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamProject
func (a *IamAPIService) PutIamProjectsByOwnerByNameExecute(r IamAPIPutIamProjectsByOwnerByNameRequest) (*IamProject, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamProject
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamProjectsByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/projects/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamProjectsInput == nil {
return localVarReturnValue, nil, reportError("iamProjectsInput 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.iamProjectsInput
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 IamAPIPutIamRolesByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamInput *IamInput
}
func (r IamAPIPutIamRolesByOwnerByNameRequest) IamInput(iamInput IamInput) IamAPIPutIamRolesByOwnerByNameRequest {
r.iamInput = &iamInput
return r
}
func (r IamAPIPutIamRolesByOwnerByNameRequest) Execute() (*IamRole, *http.Response, error) {
return r.ApiService.PutIamRolesByOwnerByNameExecute(r)
}
/*
PutIamRolesByOwnerByName Changes who is in a role, or which roles it includes.
Changes who is in a role, or which roles it includes. Access changes for
everyone in it as soon as the write lands. What the role is called does not
change, and neither does when it was created.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name Name addresses the team on update and names it on create; every other field is content and binds from the BODY, never the URL.
@return IamAPIPutIamRolesByOwnerByNameRequest
*/
func (a *IamAPIService) PutIamRolesByOwnerByName(ctx context.Context, owner string, name string) IamAPIPutIamRolesByOwnerByNameRequest {
return IamAPIPutIamRolesByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamRole
func (a *IamAPIService) PutIamRolesByOwnerByNameExecute(r IamAPIPutIamRolesByOwnerByNameRequest) (*IamRole, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamRole
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamRolesByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/roles/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamInput == nil {
return localVarReturnValue, nil, reportError("iamInput 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.iamInput
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 IamAPIPutIamScimV2UsersByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIPutIamScimV2UsersByOwnerByNameRequest) Execute() (*http.Response, error) {
return r.ApiService.PutIamScimV2UsersByOwnerByNameExecute(r)
}
/*
PutIamScimV2UsersByOwnerByName Overwrites a person's SCIM attributes with what your identity provider sends — how a change made there lands here.
Overwrites a person's SCIM attributes with what your identity
provider sends — how a change made there lands here.
Only the attributes SCIM describes are replaced. Anything the standard does not
cover — their multi-factor enrolment above all — survives untouched, so a
routine sync from your IdP can never quietly strip someone's second factor or
bring a deleted account back.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIPutIamScimV2UsersByOwnerByNameRequest
*/
func (a *IamAPIService) PutIamScimV2UsersByOwnerByName(ctx context.Context, owner string, name string) IamAPIPutIamScimV2UsersByOwnerByNameRequest {
return IamAPIPutIamScimV2UsersByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
func (a *IamAPIService) PutIamScimV2UsersByOwnerByNameExecute(r IamAPIPutIamScimV2UsersByOwnerByNameRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamScimV2UsersByOwnerByName")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/scim/v2/Users/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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{}
// 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 nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type IamAPIPutIamTeamsByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
name string
iamTeamsInput *IamTeamsInput
}
func (r IamAPIPutIamTeamsByNameRequest) IamTeamsInput(iamTeamsInput IamTeamsInput) IamAPIPutIamTeamsByNameRequest {
r.iamTeamsInput = &iamTeamsInput
return r
}
func (r IamAPIPutIamTeamsByNameRequest) Execute() (*IamTeam, *http.Response, error) {
return r.ApiService.PutIamTeamsByNameExecute(r)
}
/*
PutIamTeamsByName Changes who is in a team.
Changes who is in a team. Access changes for
everyone in it as soon as the write lands. The name and the created stamp do
not change.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param name Name addresses the team on update and names it on create; every other field is content and binds from the BODY, never the URL.
@return IamAPIPutIamTeamsByNameRequest
*/
func (a *IamAPIService) PutIamTeamsByName(ctx context.Context, name string) IamAPIPutIamTeamsByNameRequest {
return IamAPIPutIamTeamsByNameRequest{
ApiService: a,
ctx: ctx,
name: name,
}
}
// Execute executes the request
//
// @return IamTeam
func (a *IamAPIService) PutIamTeamsByNameExecute(r IamAPIPutIamTeamsByNameRequest) (*IamTeam, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamTeam
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamTeamsByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/teams/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamTeamsInput == nil {
return localVarReturnValue, nil, reportError("iamTeamsInput 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.iamTeamsInput
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 IamAPIPutIamTermsRequest struct {
ctx context.Context
ApiService *IamAPIService
iamTermsBody *IamTermsBody
cookie *string
authorization *string
secFetchSite *string
origin *string
host *string
contentType *string
xForwardedFor *string
}
func (r IamAPIPutIamTermsRequest) IamTermsBody(iamTermsBody IamTermsBody) IamAPIPutIamTermsRequest {
r.iamTermsBody = &iamTermsBody
return r
}
func (r IamAPIPutIamTermsRequest) Cookie(cookie string) IamAPIPutIamTermsRequest {
r.cookie = &cookie
return r
}
func (r IamAPIPutIamTermsRequest) Authorization(authorization string) IamAPIPutIamTermsRequest {
r.authorization = &authorization
return r
}
func (r IamAPIPutIamTermsRequest) SecFetchSite(secFetchSite string) IamAPIPutIamTermsRequest {
r.secFetchSite = &secFetchSite
return r
}
func (r IamAPIPutIamTermsRequest) Origin(origin string) IamAPIPutIamTermsRequest {
r.origin = &origin
return r
}
func (r IamAPIPutIamTermsRequest) Host(host string) IamAPIPutIamTermsRequest {
r.host = &host
return r
}
func (r IamAPIPutIamTermsRequest) ContentType(contentType string) IamAPIPutIamTermsRequest {
r.contentType = &contentType
return r
}
func (r IamAPIPutIamTermsRequest) XForwardedFor(xForwardedFor string) IamAPIPutIamTermsRequest {
r.xForwardedFor = &xForwardedFor
return r
}
func (r IamAPIPutIamTermsRequest) Execute() (*IamAnswer, *http.Response, error) {
return r.ApiService.PutIamTermsExecute(r)
}
/*
PutIamTerms Records that the signed-in caller accepted the terms and the acceptable use policy, at the versions named.
Records that the signed-in caller accepted the terms and the
acceptable use policy, at the versions named. It is how a person who arrived by
a social provider, whose account the callback already made, records the same
acceptance a code sign-up records at creation. Only the caller's own row is
reachable.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIPutIamTermsRequest
*/
func (a *IamAPIService) PutIamTerms(ctx context.Context) IamAPIPutIamTermsRequest {
return IamAPIPutIamTermsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamAnswer
func (a *IamAPIService) PutIamTermsExecute(r IamAPIPutIamTermsRequest) (*IamAnswer, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamAnswer
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamTerms")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/terms"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamTermsBody == nil {
return localVarReturnValue, nil, reportError("iamTermsBody 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
}
if r.cookie != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Cookie", r.cookie, "simple", "")
}
if r.authorization != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
}
if r.secFetchSite != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Sec-Fetch-Site", r.secFetchSite, "simple", "")
}
if r.origin != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Origin", r.origin, "simple", "")
}
if r.host != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Host", r.host, "simple", "")
}
if r.contentType != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Content-Type", r.contentType, "simple", "")
}
if r.xForwardedFor != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "X-Forwarded-For", r.xForwardedFor, "simple", "")
}
// body params
localVarPostBody = r.iamTermsBody
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,
}
if localVarHTTPResponse.StatusCode == 400 {
var v IamAnswer
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
}
if localVarHTTPResponse.StatusCode == 403 {
var v IamAnswer
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
}
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 IamAPIPutIamUsersByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamUpdateInput *IamUpdateInput
}
func (r IamAPIPutIamUsersByOwnerByNameRequest) IamUpdateInput(iamUpdateInput IamUpdateInput) IamAPIPutIamUsersByOwnerByNameRequest {
r.iamUpdateInput = &iamUpdateInput
return r
}
func (r IamAPIPutIamUsersByOwnerByNameRequest) Execute() (*IamUser, *http.Response, error) {
return r.ApiService.PutIamUsersByOwnerByNameExecute(r)
}
/*
PutIamUsersByOwnerByName Changes a person's profile, their roles, or the credentials they sign in with.
Changes a person's profile, their roles, or the credentials they sign
in with. Send a password to reset it; leave it out and their current one keeps
working.
Who they are does not change: their organization, username and the identifier
their existing sessions are keyed on all survive the write, so an update never
signs anyone out.
A SuperAdmin's account is changed only by a SuperAdmin.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIPutIamUsersByOwnerByNameRequest
*/
func (a *IamAPIService) PutIamUsersByOwnerByName(ctx context.Context, owner string, name string) IamAPIPutIamUsersByOwnerByNameRequest {
return IamAPIPutIamUsersByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamUser
func (a *IamAPIService) PutIamUsersByOwnerByNameExecute(r IamAPIPutIamUsersByOwnerByNameRequest) (*IamUser, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamUser
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamUsersByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/users/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamUpdateInput == nil {
return localVarReturnValue, nil, reportError("iamUpdateInput 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.iamUpdateInput
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 IamAPIPutIamWorkspacesByOwnerByNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamWorkspacesInput *IamWorkspacesInput
}
func (r IamAPIPutIamWorkspacesByOwnerByNameRequest) IamWorkspacesInput(iamWorkspacesInput IamWorkspacesInput) IamAPIPutIamWorkspacesByOwnerByNameRequest {
r.iamWorkspacesInput = &iamWorkspacesInput
return r
}
func (r IamAPIPutIamWorkspacesByOwnerByNameRequest) Execute() (*IamWorkspace, *http.Response, error) {
return r.ApiService.PutIamWorkspacesByOwnerByNameExecute(r)
}
/*
PutIamWorkspacesByOwnerByName Changes a workspace's settings.
Changes a workspace's settings. What it is called does not change, and
neither does when it was created.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIPutIamWorkspacesByOwnerByNameRequest
*/
func (a *IamAPIService) PutIamWorkspacesByOwnerByName(ctx context.Context, owner string, name string) IamAPIPutIamWorkspacesByOwnerByNameRequest {
return IamAPIPutIamWorkspacesByOwnerByNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamWorkspace
func (a *IamAPIService) PutIamWorkspacesByOwnerByNameExecute(r IamAPIPutIamWorkspacesByOwnerByNameRequest) (*IamWorkspace, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamWorkspace
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.PutIamWorkspacesByOwnerByName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/workspaces/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamWorkspacesInput == nil {
return localVarReturnValue, nil, reportError("iamWorkspacesInput 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.iamWorkspacesInput
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 IamAPIReleaseOrganizationNameRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
}
func (r IamAPIReleaseOrganizationNameRequest) Execute() (*IamReleaseOutput, *http.Response, error) {
return r.ApiService.ReleaseOrganizationNameExecute(r)
}
/*
ReleaseOrganizationName Frees the name of a deleted organization so it can be founded again.
Frees the name of a deleted organization so it can be founded again.
Deleting an organization leaves its name held, because every service keys a
tenant by that name; releasing it is a SuperAdmin's decision, recorded on the
audit trail, and it is refused while anything IAM keeps is still keyed by the
name. Everything else keyed by it across the estate must be purged first.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIReleaseOrganizationNameRequest
*/
func (a *IamAPIService) ReleaseOrganizationName(ctx context.Context, owner string, name string) IamAPIReleaseOrganizationNameRequest {
return IamAPIReleaseOrganizationNameRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamReleaseOutput
func (a *IamAPIService) ReleaseOrganizationNameExecute(r IamAPIReleaseOrganizationNameRequest) (*IamReleaseOutput, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamReleaseOutput
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.ReleaseOrganizationName")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/organizations/tombstones/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -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 IamAPISetOrganizationAvatarRequest struct {
ctx context.Context
ApiService *IamAPIService
iamSetAvatarInput *IamSetAvatarInput
}
func (r IamAPISetOrganizationAvatarRequest) IamSetAvatarInput(iamSetAvatarInput IamSetAvatarInput) IamAPISetOrganizationAvatarRequest {
r.iamSetAvatarInput = &iamSetAvatarInput
return r
}
func (r IamAPISetOrganizationAvatarRequest) Execute() (*IamOrganization, *http.Response, error) {
return r.ApiService.SetOrganizationAvatarExecute(r)
}
/*
SetOrganizationAvatar Changes how an organization appears across Hanzo: the square mark beside its name, as an uploaded image or as a single emoji.
Changes how an organization appears across Hanzo: the square mark
beside its name, as an uploaded image or as a single emoji. Sending an image
clears the emoji and sending an emoji clears the image — an organization has
one mark, not a preference order — and sending neither clears both, which is
how it goes back to being drawn as its initial.
An image is an https link or the bytes inline as a data URL, up to 96 KiB.
Anyone who administers the organization may set this; it is not reserved to
the platform.
It writes the two fields onto the stored row and touches nothing else, which
update cannot do: update replaces the whole record, and a record read back
first arrives masked, so a read-modify-write through it would persist the mask
over the organization's own credential settings.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPISetOrganizationAvatarRequest
*/
func (a *IamAPIService) SetOrganizationAvatar(ctx context.Context) IamAPISetOrganizationAvatarRequest {
return IamAPISetOrganizationAvatarRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamOrganization
func (a *IamAPIService) SetOrganizationAvatarExecute(r IamAPISetOrganizationAvatarRequest) (*IamOrganization, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamOrganization
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.SetOrganizationAvatar")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/organizations/avatar"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamSetAvatarInput == nil {
return localVarReturnValue, nil, reportError("iamSetAvatarInput 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.iamSetAvatarInput
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 IamAPISetOrganizationProfileRequest struct {
ctx context.Context
ApiService *IamAPIService
iamSetProfileInput *IamSetProfileInput
}
func (r IamAPISetOrganizationProfileRequest) IamSetProfileInput(iamSetProfileInput IamSetProfileInput) IamAPISetOrganizationProfileRequest {
r.iamSetProfileInput = &iamSetProfileInput
return r
}
func (r IamAPISetOrganizationProfileRequest) Execute() (*IamOrganization, *http.Response, error) {
return r.ApiService.SetOrganizationProfileExecute(r)
}
/*
SetOrganizationProfile Changes how an organization reads: its display name, its website and its favicon.
Changes how an organization reads: its display name, its website
and its favicon.
IT EXISTS FOR THE REASON SetAvatar DOES, and the reason is worth stating
because the obvious alternative is a trap. Update REPLACES the whole record,
so a caller that wants to change one field has to send every other field
back — and a record read back first arrives MASKED, so the read half of that
read-modify-write hands you "***" for the master password and the salt, and
the write half stores it. Renaming an organization through Update therefore
costs it its credential settings; sending only the new name costs it
everything else. Neither is a rename.
So this writes the fields it names and touches nothing else. A nil pointer is
not sent and not changed; an empty string is sent and clears the field.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPISetOrganizationProfileRequest
*/
func (a *IamAPIService) SetOrganizationProfile(ctx context.Context) IamAPISetOrganizationProfileRequest {
return IamAPISetOrganizationProfileRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamOrganization
func (a *IamAPIService) SetOrganizationProfileExecute(r IamAPISetOrganizationProfileRequest) (*IamOrganization, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamOrganization
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.SetOrganizationProfile")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/organizations/profile"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamSetProfileInput == nil {
return localVarReturnValue, nil, reportError("iamSetProfileInput 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.iamSetProfileInput
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 IamAPIUpdateOrganizationRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamUpdateOrganizationInput *IamUpdateOrganizationInput
}
func (r IamAPIUpdateOrganizationRequest) IamUpdateOrganizationInput(iamUpdateOrganizationInput IamUpdateOrganizationInput) IamAPIUpdateOrganizationRequest {
r.iamUpdateOrganizationInput = &iamUpdateOrganizationInput
return r
}
func (r IamAPIUpdateOrganizationRequest) Execute() (*IamOrganization, *http.Response, error) {
return r.ApiService.UpdateOrganizationExecute(r)
}
/*
UpdateOrganization Changes an organization's display, its defaults and the sign-in rules everyone in it inherits.
Changes an organization's display, its defaults and the sign-in rules
everyone in it inherits. Which organization it is does not change, and neither
does when it was created.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIUpdateOrganizationRequest
*/
func (a *IamAPIService) UpdateOrganization(ctx context.Context, owner string, name string) IamAPIUpdateOrganizationRequest {
return IamAPIUpdateOrganizationRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamOrganization
func (a *IamAPIService) UpdateOrganizationExecute(r IamAPIUpdateOrganizationRequest) (*IamOrganization, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamOrganization
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.UpdateOrganization")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/organizations/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamUpdateOrganizationInput == nil {
return localVarReturnValue, nil, reportError("iamUpdateOrganizationInput 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.iamUpdateOrganizationInput
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 IamAPIUpdateProviderRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamProvider *IamProvider
}
func (r IamAPIUpdateProviderRequest) IamProvider(iamProvider IamProvider) IamAPIUpdateProviderRequest {
r.iamProvider = &iamProvider
return r
}
func (r IamAPIUpdateProviderRequest) Execute() (*IamMutationResult, *http.Response, error) {
return r.ApiService.UpdateProviderExecute(r)
}
/*
UpdateProvider Changes a provider's settings or rotates the credentials it holds.
Changes a provider's settings or rotates the credentials it
holds. The change takes effect on the next sign-in through it — sessions
already issued are unaffected.
A provider that is not there answers "nothing changed" rather than an error, so
the call is safe to repeat.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIUpdateProviderRequest
*/
func (a *IamAPIService) UpdateProvider(ctx context.Context, owner string, name string) IamAPIUpdateProviderRequest {
return IamAPIUpdateProviderRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamMutationResult
func (a *IamAPIService) UpdateProviderExecute(r IamAPIUpdateProviderRequest) (*IamMutationResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamMutationResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.UpdateProvider")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/providers/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamProvider == nil {
return localVarReturnValue, nil, reportError("iamProvider 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.iamProvider
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 IamAPIUpdateSessionRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
application string
iamUpdateSessionIn *IamUpdateSessionIn
}
func (r IamAPIUpdateSessionRequest) IamUpdateSessionIn(iamUpdateSessionIn IamUpdateSessionIn) IamAPIUpdateSessionRequest {
r.iamUpdateSessionIn = &iamUpdateSessionIn
return r
}
func (r IamAPIUpdateSessionRequest) Execute() (*IamSession, *http.Response, error) {
return r.ApiService.UpdateSessionExecute(r)
}
/*
UpdateSession Names the browsers a session keeps — signing out the ones you leave off while the session itself stays live.
Names the browsers a session keeps — signing out the ones you leave off
while the session itself stays live. A session that does not exist is reported
as missing rather than created.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@param application
@return IamAPIUpdateSessionRequest
*/
func (a *IamAPIService) UpdateSession(ctx context.Context, owner string, name string, application string) IamAPIUpdateSessionRequest {
return IamAPIUpdateSessionRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
application: application,
}
}
// Execute executes the request
//
// @return IamSession
func (a *IamAPIService) UpdateSessionExecute(r IamAPIUpdateSessionRequest) (*IamSession, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamSession
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.UpdateSession")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/sessions/{owner}/{name}/{application}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"application"+"}", url.PathEscape(parameterValueToString(r.application, "application")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamUpdateSessionIn == nil {
return localVarReturnValue, nil, reportError("iamUpdateSessionIn 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.iamUpdateSessionIn
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 IamAPIUpdateTokenRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamToken *IamToken
}
func (r IamAPIUpdateTokenRequest) IamToken(iamToken IamToken) IamAPIUpdateTokenRequest {
r.iamToken = &iamToken
return r
}
func (r IamAPIUpdateTokenRequest) Execute() (*IamTokenMutation, *http.Response, error) {
return r.ApiService.UpdateTokenExecute(r)
}
/*
UpdateToken Changes an access token's scope or expiry.
Changes an access token's scope or expiry.
A token that is not there answers "nothing changed" rather than an error, so
the call is safe to repeat.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIUpdateTokenRequest
*/
func (a *IamAPIService) UpdateToken(ctx context.Context, owner string, name string) IamAPIUpdateTokenRequest {
return IamAPIUpdateTokenRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamTokenMutation
func (a *IamAPIService) UpdateTokenExecute(r IamAPIUpdateTokenRequest) (*IamTokenMutation, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamTokenMutation
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.UpdateToken")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/tokens/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamToken == nil {
return localVarReturnValue, nil, reportError("iamToken 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.iamToken
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 IamAPIUpdateWebauthnCredentialRequest struct {
ctx context.Context
ApiService *IamAPIService
owner string
name string
iamWebauthnCredential *IamWebauthnCredential
}
func (r IamAPIUpdateWebauthnCredentialRequest) IamWebauthnCredential(iamWebauthnCredential IamWebauthnCredential) IamAPIUpdateWebauthnCredentialRequest {
r.iamWebauthnCredential = &iamWebauthnCredential
return r
}
func (r IamAPIUpdateWebauthnCredentialRequest) Execute() (*IamWebauthnCredentialMutationResult, *http.Response, error) {
return r.ApiService.UpdateWebauthnCredentialExecute(r)
}
/*
UpdateWebauthnCredential Renames a registered passkey or security key, so a person can tell their devices apart.
Renames a registered passkey or security key, so a
person can tell their devices apart.
A credential that is not there answers "nothing changed" rather than an error,
so the call is safe to repeat.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param owner
@param name
@return IamAPIUpdateWebauthnCredentialRequest
*/
func (a *IamAPIService) UpdateWebauthnCredential(ctx context.Context, owner string, name string) IamAPIUpdateWebauthnCredentialRequest {
return IamAPIUpdateWebauthnCredentialRequest{
ApiService: a,
ctx: ctx,
owner: owner,
name: name,
}
}
// Execute executes the request
//
// @return IamWebauthnCredentialMutationResult
func (a *IamAPIService) UpdateWebauthnCredentialExecute(r IamAPIUpdateWebauthnCredentialRequest) (*IamWebauthnCredentialMutationResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamWebauthnCredentialMutationResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.UpdateWebauthnCredential")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/webauthn-credentials/{owner}/{name}"
localVarPath = strings.Replace(localVarPath, "{"+"owner"+"}", url.PathEscape(parameterValueToString(r.owner, "owner")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamWebauthnCredential == nil {
return localVarReturnValue, nil, reportError("iamWebauthnCredential 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.iamWebauthnCredential
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 IamAPIUpsertApplicationRequest struct {
ctx context.Context
ApiService *IamAPIService
iamRegistration *IamRegistration
authorization *string
}
func (r IamAPIUpsertApplicationRequest) IamRegistration(iamRegistration IamRegistration) IamAPIUpsertApplicationRequest {
r.iamRegistration = &iamRegistration
return r
}
func (r IamAPIUpsertApplicationRequest) Authorization(authorization string) IamAPIUpsertApplicationRequest {
r.authorization = &authorization
return r
}
func (r IamAPIUpsertApplicationRequest) Execute() (*IamReply, *http.Response, error) {
return r.ApiService.UpsertApplicationExecute(r)
}
/*
UpsertApplication Creates an application or updates it in place, so a deployment can declare the applications it needs and run the same declaration on every environment and on every redeploy.
Creates an application or updates it in place, so a
deployment can declare the applications it needs and run the same declaration
on every environment and on every redeploy.
It says which of the two it did. Leave the client secret out and the existing
one is kept — so re-running your deployment does not rotate a credential your
running services are holding.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIUpsertApplicationRequest
*/
func (a *IamAPIService) UpsertApplication(ctx context.Context) IamAPIUpsertApplicationRequest {
return IamAPIUpsertApplicationRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamReply
func (a *IamAPIService) UpsertApplicationExecute(r IamAPIUpsertApplicationRequest) (*IamReply, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamReply
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.UpsertApplication")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/admin/applications/upsert"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamRegistration == nil {
return localVarReturnValue, nil, reportError("iamRegistration 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
}
if r.authorization != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
}
// body params
localVarPostBody = r.iamRegistration
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,
}
if localVarHTTPResponse.StatusCode == 400 {
var v IamReply
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
}
if localVarHTTPResponse.StatusCode == 401 {
var v IamReply
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
}
if localVarHTTPResponse.StatusCode == 409 {
var v IamReply
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
}
if localVarHTTPResponse.StatusCode == 500 {
var v IamReply
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
}
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 IamAPIUpsertUserRequest struct {
ctx context.Context
ApiService *IamAPIService
iamPerson *IamPerson
authorization *string
}
func (r IamAPIUpsertUserRequest) IamPerson(iamPerson IamPerson) IamAPIUpsertUserRequest {
r.iamPerson = &iamPerson
return r
}
func (r IamAPIUpsertUserRequest) Authorization(authorization string) IamAPIUpsertUserRequest {
r.authorization = &authorization
return r
}
func (r IamAPIUpsertUserRequest) Execute() (*IamReply, *http.Response, error) {
return r.ApiService.UpsertUserExecute(r)
}
/*
UpsertUser Creates a person or updates them in place, so a deployment can declare the accounts it needs and re-run that declaration safely.
Creates a person or updates them in place, so a deployment can
declare the accounts it needs and re-run that declaration safely.
It DESCRIBES an account it meets and GRANTS only to one it creates: org-admin is
never raised on a row that already exists, and a machine identity is answered by
name rather than adopted. Both are properties of the update itself, so a
steady-state reconcile — which changes neither — is unaffected.
Passwords are hashed before they are stored. Leave the password out and their
current one is kept, so a redeploy never locks somebody out; send the same one
again and it is kept too, so a steady-state re-run is not a rotation.
A SuperAdmin's password, email and phone are set when the account is created
and kept on every run after.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return IamAPIUpsertUserRequest
*/
func (a *IamAPIService) UpsertUser(ctx context.Context) IamAPIUpsertUserRequest {
return IamAPIUpsertUserRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return IamReply
func (a *IamAPIService) UpsertUserExecute(r IamAPIUpsertUserRequest) (*IamReply, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *IamReply
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IamAPIService.UpsertUser")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/iam/admin/users/upsert"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.iamPerson == nil {
return localVarReturnValue, nil, reportError("iamPerson 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
}
if r.authorization != nil {
parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
}
// body params
localVarPostBody = r.iamPerson
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,
}
if localVarHTTPResponse.StatusCode == 400 {
var v IamReply
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
}
if localVarHTTPResponse.StatusCode == 401 {
var v IamReply
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
}
if localVarHTTPResponse.StatusCode == 500 {
var v IamReply
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
}
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
}