api_access_api.go

/*
OpenAPI definition

No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

API version: v0
*/

// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

package openapi

import (
	"bytes"
	"context"
	"io"
	"net/http"
	"net/url"
	"strings"
)

type AccessApiAPI interface {

	/*
		AcceptInvitation Method for AcceptInvitation

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@param id
		@return ApiAcceptInvitationRequest
	*/
	AcceptInvitation(ctx context.Context, id int64) ApiAcceptInvitationRequest

	// AcceptInvitationExecute executes the request
	AcceptInvitationExecute(r ApiAcceptInvitationRequest) (*http.Response, error)

	/*
		DeclineInvitation Method for DeclineInvitation

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@param id
		@return ApiDeclineInvitationRequest
	*/
	DeclineInvitation(ctx context.Context, id int64) ApiDeclineInvitationRequest

	// DeclineInvitationExecute executes the request
	DeclineInvitationExecute(r ApiDeclineInvitationRequest) (*http.Response, error)

	/*
		GetInvitation Method for GetInvitation

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@param id
		@return ApiGetInvitationRequest
	*/
	GetInvitation(ctx context.Context, id int64) ApiGetInvitationRequest

	// GetInvitationExecute executes the request
	//  @return InvitationResponse
	GetInvitationExecute(r ApiGetInvitationRequest) (*InvitationResponse, *http.Response, error)

	/*
		GetReceivedInvitations Method for GetReceivedInvitations

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@return ApiGetReceivedInvitationsRequest
	*/
	GetReceivedInvitations(ctx context.Context) ApiGetReceivedInvitationsRequest

	// GetReceivedInvitationsExecute executes the request
	//  @return []InvitationResponse
	GetReceivedInvitationsExecute(r ApiGetReceivedInvitationsRequest) ([]InvitationResponse, *http.Response, error)

	/*
		GetSentInvitations Method for GetSentInvitations

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@return ApiGetSentInvitationsRequest
	*/
	GetSentInvitations(ctx context.Context) ApiGetSentInvitationsRequest

	// GetSentInvitationsExecute executes the request
	//  @return []InvitationResponse
	GetSentInvitationsExecute(r ApiGetSentInvitationsRequest) ([]InvitationResponse, *http.Response, error)

	/*
		InviteByEmail Method for InviteByEmail

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@return ApiInviteByEmailRequest
	*/
	InviteByEmail(ctx context.Context) ApiInviteByEmailRequest

	// InviteByEmailExecute executes the request
	//  @return InvitationResponse
	InviteByEmailExecute(r ApiInviteByEmailRequest) (*InvitationResponse, *http.Response, error)

	/*
		RemoveApiServerPrivileges Method for RemoveApiServerPrivileges

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@return ApiRemoveApiServerPrivilegesRequest
	*/
	RemoveApiServerPrivileges(ctx context.Context) ApiRemoveApiServerPrivilegesRequest

	// RemoveApiServerPrivilegesExecute executes the request
	RemoveApiServerPrivilegesExecute(r ApiRemoveApiServerPrivilegesRequest) (*http.Response, error)

	/*
		RemoveClientPrivileges Method for RemoveClientPrivileges

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@return ApiRemoveClientPrivilegesRequest
	*/
	RemoveClientPrivileges(ctx context.Context) ApiRemoveClientPrivilegesRequest

	// RemoveClientPrivilegesExecute executes the request
	RemoveClientPrivilegesExecute(r ApiRemoveClientPrivilegesRequest) (*http.Response, error)

	/*
		RemoveOrganizationPrivileges Method for RemoveOrganizationPrivileges

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@return ApiRemoveOrganizationPrivilegesRequest
	*/
	RemoveOrganizationPrivileges(ctx context.Context) ApiRemoveOrganizationPrivilegesRequest

	// RemoveOrganizationPrivilegesExecute executes the request
	RemoveOrganizationPrivilegesExecute(r ApiRemoveOrganizationPrivilegesRequest) (*http.Response, error)

	/*
		RemoveServicePrivileges Method for RemoveServicePrivileges

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@return ApiRemoveServicePrivilegesRequest
	*/
	RemoveServicePrivileges(ctx context.Context) ApiRemoveServicePrivilegesRequest

	// RemoveServicePrivilegesExecute executes the request
	RemoveServicePrivilegesExecute(r ApiRemoveServicePrivilegesRequest) (*http.Response, error)

	/*
		UpdateApiServerPrivileges Method for UpdateApiServerPrivileges

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@return ApiUpdateApiServerPrivilegesRequest
	*/
	UpdateApiServerPrivileges(ctx context.Context) ApiUpdateApiServerPrivilegesRequest

	// UpdateApiServerPrivilegesExecute executes the request
	//  @return ApiServerAccessResponse
	UpdateApiServerPrivilegesExecute(r ApiUpdateApiServerPrivilegesRequest) (*ApiServerAccessResponse, *http.Response, error)

	/*
		UpdateClientPrivileges Method for UpdateClientPrivileges

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@return ApiUpdateClientPrivilegesRequest
	*/
	UpdateClientPrivileges(ctx context.Context) ApiUpdateClientPrivilegesRequest

	// UpdateClientPrivilegesExecute executes the request
	//  @return ClientAccessResponse
	UpdateClientPrivilegesExecute(r ApiUpdateClientPrivilegesRequest) (*ClientAccessResponse, *http.Response, error)

	/*
		UpdateOrganizationPrivileges Method for UpdateOrganizationPrivileges

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@return ApiUpdateOrganizationPrivilegesRequest
	*/
	UpdateOrganizationPrivileges(ctx context.Context) ApiUpdateOrganizationPrivilegesRequest

	// UpdateOrganizationPrivilegesExecute executes the request
	//  @return OrganizationAccessResponse
	UpdateOrganizationPrivilegesExecute(r ApiUpdateOrganizationPrivilegesRequest) (*OrganizationAccessResponse, *http.Response, error)

	/*
		UpdateServicePrivileges Method for UpdateServicePrivileges

		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
		@return ApiUpdateServicePrivilegesRequest
	*/
	UpdateServicePrivileges(ctx context.Context) ApiUpdateServicePrivilegesRequest

	// UpdateServicePrivilegesExecute executes the request
	//  @return ServiceAccessResponse
	UpdateServicePrivilegesExecute(r ApiUpdateServicePrivilegesRequest) (*ServiceAccessResponse, *http.Response, error)
}

// AccessApiAPIService AccessApiAPI service
type AccessApiAPIService service

type ApiAcceptInvitationRequest struct {
	ctx           context.Context
	ApiService    AccessApiAPI
	id            int64
	authorization *string
	dPoP          *string
}

func (r ApiAcceptInvitationRequest) Authorization(authorization string) ApiAcceptInvitationRequest {
	r.authorization = &authorization
	return r
}

func (r ApiAcceptInvitationRequest) DPoP(dPoP string) ApiAcceptInvitationRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiAcceptInvitationRequest) Execute() (*http.Response, error) {
	return r.ApiService.AcceptInvitationExecute(r)
}

/*
AcceptInvitation Method for AcceptInvitation

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param id
	@return ApiAcceptInvitationRequest
*/
func (a *AccessApiAPIService) AcceptInvitation(ctx context.Context, id int64) ApiAcceptInvitationRequest {
	return ApiAcceptInvitationRequest{
		ApiService: a,
		ctx:        ctx,
		id:         id,
	}
}

// Execute executes the request
func (a *AccessApiAPIService) AcceptInvitationExecute(r ApiAcceptInvitationRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodPost
		localVarPostBody   interface{}
		formFiles          []formFile
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.AcceptInvitation")
	if err != nil {
		return nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/invite/{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{}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "simple", "")
	}
	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 ApiDeclineInvitationRequest struct {
	ctx           context.Context
	ApiService    AccessApiAPI
	id            int64
	authorization *string
	dPoP          *string
}

func (r ApiDeclineInvitationRequest) Authorization(authorization string) ApiDeclineInvitationRequest {
	r.authorization = &authorization
	return r
}

func (r ApiDeclineInvitationRequest) DPoP(dPoP string) ApiDeclineInvitationRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiDeclineInvitationRequest) Execute() (*http.Response, error) {
	return r.ApiService.DeclineInvitationExecute(r)
}

/*
DeclineInvitation Method for DeclineInvitation

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param id
	@return ApiDeclineInvitationRequest
*/
func (a *AccessApiAPIService) DeclineInvitation(ctx context.Context, id int64) ApiDeclineInvitationRequest {
	return ApiDeclineInvitationRequest{
		ApiService: a,
		ctx:        ctx,
		id:         id,
	}
}

// Execute executes the request
func (a *AccessApiAPIService) DeclineInvitationExecute(r ApiDeclineInvitationRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodDelete
		localVarPostBody   interface{}
		formFiles          []formFile
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.DeclineInvitation")
	if err != nil {
		return nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/invite/{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{}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "simple", "")
	}
	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 ApiGetInvitationRequest struct {
	ctx           context.Context
	ApiService    AccessApiAPI
	id            int64
	authorization *string
	dPoP          *string
}

func (r ApiGetInvitationRequest) Authorization(authorization string) ApiGetInvitationRequest {
	r.authorization = &authorization
	return r
}

func (r ApiGetInvitationRequest) DPoP(dPoP string) ApiGetInvitationRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiGetInvitationRequest) Execute() (*InvitationResponse, *http.Response, error) {
	return r.ApiService.GetInvitationExecute(r)
}

/*
GetInvitation Method for GetInvitation

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param id
	@return ApiGetInvitationRequest
*/
func (a *AccessApiAPIService) GetInvitation(ctx context.Context, id int64) ApiGetInvitationRequest {
	return ApiGetInvitationRequest{
		ApiService: a,
		ctx:        ctx,
		id:         id,
	}
}

// Execute executes the request
//
//	@return InvitationResponse
func (a *AccessApiAPIService) GetInvitationExecute(r ApiGetInvitationRequest) (*InvitationResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *InvitationResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.GetInvitation")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/invite/{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"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "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,
		}
		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 ApiGetReceivedInvitationsRequest struct {
	ctx           context.Context
	ApiService    AccessApiAPI
	authorization *string
	dPoP          *string
}

func (r ApiGetReceivedInvitationsRequest) Authorization(authorization string) ApiGetReceivedInvitationsRequest {
	r.authorization = &authorization
	return r
}

func (r ApiGetReceivedInvitationsRequest) DPoP(dPoP string) ApiGetReceivedInvitationsRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiGetReceivedInvitationsRequest) Execute() ([]InvitationResponse, *http.Response, error) {
	return r.ApiService.GetReceivedInvitationsExecute(r)
}

/*
GetReceivedInvitations Method for GetReceivedInvitations

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiGetReceivedInvitationsRequest
*/
func (a *AccessApiAPIService) GetReceivedInvitations(ctx context.Context) ApiGetReceivedInvitationsRequest {
	return ApiGetReceivedInvitationsRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return []InvitationResponse
func (a *AccessApiAPIService) GetReceivedInvitationsExecute(r ApiGetReceivedInvitationsRequest) ([]InvitationResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue []InvitationResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.GetReceivedInvitations")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/invite/received"

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

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "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,
		}
		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 ApiGetSentInvitationsRequest struct {
	ctx           context.Context
	ApiService    AccessApiAPI
	authorization *string
	dPoP          *string
}

func (r ApiGetSentInvitationsRequest) Authorization(authorization string) ApiGetSentInvitationsRequest {
	r.authorization = &authorization
	return r
}

func (r ApiGetSentInvitationsRequest) DPoP(dPoP string) ApiGetSentInvitationsRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiGetSentInvitationsRequest) Execute() ([]InvitationResponse, *http.Response, error) {
	return r.ApiService.GetSentInvitationsExecute(r)
}

/*
GetSentInvitations Method for GetSentInvitations

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiGetSentInvitationsRequest
*/
func (a *AccessApiAPIService) GetSentInvitations(ctx context.Context) ApiGetSentInvitationsRequest {
	return ApiGetSentInvitationsRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return []InvitationResponse
func (a *AccessApiAPIService) GetSentInvitationsExecute(r ApiGetSentInvitationsRequest) ([]InvitationResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue []InvitationResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.GetSentInvitations")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/invite/sent"

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

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "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,
		}
		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 ApiInviteByEmailRequest struct {
	ctx           context.Context
	ApiService    AccessApiAPI
	inviteRequest *InviteRequest
	authorization *string
	dPoP          *string
}

func (r ApiInviteByEmailRequest) InviteRequest(inviteRequest InviteRequest) ApiInviteByEmailRequest {
	r.inviteRequest = &inviteRequest
	return r
}

func (r ApiInviteByEmailRequest) Authorization(authorization string) ApiInviteByEmailRequest {
	r.authorization = &authorization
	return r
}

func (r ApiInviteByEmailRequest) DPoP(dPoP string) ApiInviteByEmailRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiInviteByEmailRequest) Execute() (*InvitationResponse, *http.Response, error) {
	return r.ApiService.InviteByEmailExecute(r)
}

/*
InviteByEmail Method for InviteByEmail

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiInviteByEmailRequest
*/
func (a *AccessApiAPIService) InviteByEmail(ctx context.Context) ApiInviteByEmailRequest {
	return ApiInviteByEmailRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return InvitationResponse
func (a *AccessApiAPIService) InviteByEmailExecute(r ApiInviteByEmailRequest) (*InvitationResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPost
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *InvitationResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.InviteByEmail")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/invite"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.inviteRequest == nil {
		return localVarReturnValue, nil, reportError("inviteRequest 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"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "simple", "")
	}
	// body params
	localVarPostBody = r.inviteRequest
	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,
		}
		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 ApiRemoveApiServerPrivilegesRequest struct {
	ctx                              context.Context
	ApiService                       AccessApiAPI
	removeApiServerPrivilegesRequest *RemoveApiServerPrivilegesRequest
	authorization                    *string
	dPoP                             *string
}

func (r ApiRemoveApiServerPrivilegesRequest) RemoveApiServerPrivilegesRequest(removeApiServerPrivilegesRequest RemoveApiServerPrivilegesRequest) ApiRemoveApiServerPrivilegesRequest {
	r.removeApiServerPrivilegesRequest = &removeApiServerPrivilegesRequest
	return r
}

func (r ApiRemoveApiServerPrivilegesRequest) Authorization(authorization string) ApiRemoveApiServerPrivilegesRequest {
	r.authorization = &authorization
	return r
}

func (r ApiRemoveApiServerPrivilegesRequest) DPoP(dPoP string) ApiRemoveApiServerPrivilegesRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiRemoveApiServerPrivilegesRequest) Execute() (*http.Response, error) {
	return r.ApiService.RemoveApiServerPrivilegesExecute(r)
}

/*
RemoveApiServerPrivileges Method for RemoveApiServerPrivileges

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiRemoveApiServerPrivilegesRequest
*/
func (a *AccessApiAPIService) RemoveApiServerPrivileges(ctx context.Context) ApiRemoveApiServerPrivilegesRequest {
	return ApiRemoveApiServerPrivilegesRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
func (a *AccessApiAPIService) RemoveApiServerPrivilegesExecute(r ApiRemoveApiServerPrivilegesRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodPost
		localVarPostBody   interface{}
		formFiles          []formFile
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.RemoveApiServerPrivileges")
	if err != nil {
		return nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/apiserver/remove"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.removeApiServerPrivilegesRequest == nil {
		return nil, reportError("removeApiServerPrivilegesRequest 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{}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "simple", "")
	}
	// body params
	localVarPostBody = r.removeApiServerPrivilegesRequest
	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 ApiRemoveClientPrivilegesRequest struct {
	ctx                           context.Context
	ApiService                    AccessApiAPI
	removeClientPrivilegesRequest *RemoveClientPrivilegesRequest
	authorization                 *string
	dPoP                          *string
}

func (r ApiRemoveClientPrivilegesRequest) RemoveClientPrivilegesRequest(removeClientPrivilegesRequest RemoveClientPrivilegesRequest) ApiRemoveClientPrivilegesRequest {
	r.removeClientPrivilegesRequest = &removeClientPrivilegesRequest
	return r
}

func (r ApiRemoveClientPrivilegesRequest) Authorization(authorization string) ApiRemoveClientPrivilegesRequest {
	r.authorization = &authorization
	return r
}

func (r ApiRemoveClientPrivilegesRequest) DPoP(dPoP string) ApiRemoveClientPrivilegesRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiRemoveClientPrivilegesRequest) Execute() (*http.Response, error) {
	return r.ApiService.RemoveClientPrivilegesExecute(r)
}

/*
RemoveClientPrivileges Method for RemoveClientPrivileges

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiRemoveClientPrivilegesRequest
*/
func (a *AccessApiAPIService) RemoveClientPrivileges(ctx context.Context) ApiRemoveClientPrivilegesRequest {
	return ApiRemoveClientPrivilegesRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
func (a *AccessApiAPIService) RemoveClientPrivilegesExecute(r ApiRemoveClientPrivilegesRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodPost
		localVarPostBody   interface{}
		formFiles          []formFile
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.RemoveClientPrivileges")
	if err != nil {
		return nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/client/remove"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.removeClientPrivilegesRequest == nil {
		return nil, reportError("removeClientPrivilegesRequest 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{}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "simple", "")
	}
	// body params
	localVarPostBody = r.removeClientPrivilegesRequest
	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 ApiRemoveOrganizationPrivilegesRequest struct {
	ctx                                 context.Context
	ApiService                          AccessApiAPI
	removeOrganizationPrivilegesRequest *RemoveOrganizationPrivilegesRequest
	authorization                       *string
	dPoP                                *string
}

func (r ApiRemoveOrganizationPrivilegesRequest) RemoveOrganizationPrivilegesRequest(removeOrganizationPrivilegesRequest RemoveOrganizationPrivilegesRequest) ApiRemoveOrganizationPrivilegesRequest {
	r.removeOrganizationPrivilegesRequest = &removeOrganizationPrivilegesRequest
	return r
}

func (r ApiRemoveOrganizationPrivilegesRequest) Authorization(authorization string) ApiRemoveOrganizationPrivilegesRequest {
	r.authorization = &authorization
	return r
}

func (r ApiRemoveOrganizationPrivilegesRequest) DPoP(dPoP string) ApiRemoveOrganizationPrivilegesRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiRemoveOrganizationPrivilegesRequest) Execute() (*http.Response, error) {
	return r.ApiService.RemoveOrganizationPrivilegesExecute(r)
}

/*
RemoveOrganizationPrivileges Method for RemoveOrganizationPrivileges

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiRemoveOrganizationPrivilegesRequest
*/
func (a *AccessApiAPIService) RemoveOrganizationPrivileges(ctx context.Context) ApiRemoveOrganizationPrivilegesRequest {
	return ApiRemoveOrganizationPrivilegesRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
func (a *AccessApiAPIService) RemoveOrganizationPrivilegesExecute(r ApiRemoveOrganizationPrivilegesRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodPost
		localVarPostBody   interface{}
		formFiles          []formFile
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.RemoveOrganizationPrivileges")
	if err != nil {
		return nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/organization/remove"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.removeOrganizationPrivilegesRequest == nil {
		return nil, reportError("removeOrganizationPrivilegesRequest 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{}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "simple", "")
	}
	// body params
	localVarPostBody = r.removeOrganizationPrivilegesRequest
	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 ApiRemoveServicePrivilegesRequest struct {
	ctx                            context.Context
	ApiService                     AccessApiAPI
	removeServicePrivilegesRequest *RemoveServicePrivilegesRequest
	authorization                  *string
	dPoP                           *string
}

func (r ApiRemoveServicePrivilegesRequest) RemoveServicePrivilegesRequest(removeServicePrivilegesRequest RemoveServicePrivilegesRequest) ApiRemoveServicePrivilegesRequest {
	r.removeServicePrivilegesRequest = &removeServicePrivilegesRequest
	return r
}

func (r ApiRemoveServicePrivilegesRequest) Authorization(authorization string) ApiRemoveServicePrivilegesRequest {
	r.authorization = &authorization
	return r
}

func (r ApiRemoveServicePrivilegesRequest) DPoP(dPoP string) ApiRemoveServicePrivilegesRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiRemoveServicePrivilegesRequest) Execute() (*http.Response, error) {
	return r.ApiService.RemoveServicePrivilegesExecute(r)
}

/*
RemoveServicePrivileges Method for RemoveServicePrivileges

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiRemoveServicePrivilegesRequest
*/
func (a *AccessApiAPIService) RemoveServicePrivileges(ctx context.Context) ApiRemoveServicePrivilegesRequest {
	return ApiRemoveServicePrivilegesRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
func (a *AccessApiAPIService) RemoveServicePrivilegesExecute(r ApiRemoveServicePrivilegesRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodPost
		localVarPostBody   interface{}
		formFiles          []formFile
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.RemoveServicePrivileges")
	if err != nil {
		return nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/service/remove"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.removeServicePrivilegesRequest == nil {
		return nil, reportError("removeServicePrivilegesRequest 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{}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "simple", "")
	}
	// body params
	localVarPostBody = r.removeServicePrivilegesRequest
	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 ApiUpdateApiServerPrivilegesRequest struct {
	ctx                              context.Context
	ApiService                       AccessApiAPI
	updateApiServerPrivilegesRequest *UpdateApiServerPrivilegesRequest
	authorization                    *string
	dPoP                             *string
}

func (r ApiUpdateApiServerPrivilegesRequest) UpdateApiServerPrivilegesRequest(updateApiServerPrivilegesRequest UpdateApiServerPrivilegesRequest) ApiUpdateApiServerPrivilegesRequest {
	r.updateApiServerPrivilegesRequest = &updateApiServerPrivilegesRequest
	return r
}

func (r ApiUpdateApiServerPrivilegesRequest) Authorization(authorization string) ApiUpdateApiServerPrivilegesRequest {
	r.authorization = &authorization
	return r
}

func (r ApiUpdateApiServerPrivilegesRequest) DPoP(dPoP string) ApiUpdateApiServerPrivilegesRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiUpdateApiServerPrivilegesRequest) Execute() (*ApiServerAccessResponse, *http.Response, error) {
	return r.ApiService.UpdateApiServerPrivilegesExecute(r)
}

/*
UpdateApiServerPrivileges Method for UpdateApiServerPrivileges

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiUpdateApiServerPrivilegesRequest
*/
func (a *AccessApiAPIService) UpdateApiServerPrivileges(ctx context.Context) ApiUpdateApiServerPrivilegesRequest {
	return ApiUpdateApiServerPrivilegesRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return ApiServerAccessResponse
func (a *AccessApiAPIService) UpdateApiServerPrivilegesExecute(r ApiUpdateApiServerPrivilegesRequest) (*ApiServerAccessResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPost
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *ApiServerAccessResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.UpdateApiServerPrivileges")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/apiserver"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.updateApiServerPrivilegesRequest == nil {
		return localVarReturnValue, nil, reportError("updateApiServerPrivilegesRequest 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"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "simple", "")
	}
	// body params
	localVarPostBody = r.updateApiServerPrivilegesRequest
	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,
		}
		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 ApiUpdateClientPrivilegesRequest struct {
	ctx                           context.Context
	ApiService                    AccessApiAPI
	updateClientPrivilegesRequest *UpdateClientPrivilegesRequest
	authorization                 *string
	dPoP                          *string
}

func (r ApiUpdateClientPrivilegesRequest) UpdateClientPrivilegesRequest(updateClientPrivilegesRequest UpdateClientPrivilegesRequest) ApiUpdateClientPrivilegesRequest {
	r.updateClientPrivilegesRequest = &updateClientPrivilegesRequest
	return r
}

func (r ApiUpdateClientPrivilegesRequest) Authorization(authorization string) ApiUpdateClientPrivilegesRequest {
	r.authorization = &authorization
	return r
}

func (r ApiUpdateClientPrivilegesRequest) DPoP(dPoP string) ApiUpdateClientPrivilegesRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiUpdateClientPrivilegesRequest) Execute() (*ClientAccessResponse, *http.Response, error) {
	return r.ApiService.UpdateClientPrivilegesExecute(r)
}

/*
UpdateClientPrivileges Method for UpdateClientPrivileges

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiUpdateClientPrivilegesRequest
*/
func (a *AccessApiAPIService) UpdateClientPrivileges(ctx context.Context) ApiUpdateClientPrivilegesRequest {
	return ApiUpdateClientPrivilegesRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return ClientAccessResponse
func (a *AccessApiAPIService) UpdateClientPrivilegesExecute(r ApiUpdateClientPrivilegesRequest) (*ClientAccessResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPost
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *ClientAccessResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.UpdateClientPrivileges")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/client"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.updateClientPrivilegesRequest == nil {
		return localVarReturnValue, nil, reportError("updateClientPrivilegesRequest 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"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "simple", "")
	}
	// body params
	localVarPostBody = r.updateClientPrivilegesRequest
	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,
		}
		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 ApiUpdateOrganizationPrivilegesRequest struct {
	ctx                                 context.Context
	ApiService                          AccessApiAPI
	updateOrganizationPrivilegesRequest *UpdateOrganizationPrivilegesRequest
	authorization                       *string
	dPoP                                *string
}

func (r ApiUpdateOrganizationPrivilegesRequest) UpdateOrganizationPrivilegesRequest(updateOrganizationPrivilegesRequest UpdateOrganizationPrivilegesRequest) ApiUpdateOrganizationPrivilegesRequest {
	r.updateOrganizationPrivilegesRequest = &updateOrganizationPrivilegesRequest
	return r
}

func (r ApiUpdateOrganizationPrivilegesRequest) Authorization(authorization string) ApiUpdateOrganizationPrivilegesRequest {
	r.authorization = &authorization
	return r
}

func (r ApiUpdateOrganizationPrivilegesRequest) DPoP(dPoP string) ApiUpdateOrganizationPrivilegesRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiUpdateOrganizationPrivilegesRequest) Execute() (*OrganizationAccessResponse, *http.Response, error) {
	return r.ApiService.UpdateOrganizationPrivilegesExecute(r)
}

/*
UpdateOrganizationPrivileges Method for UpdateOrganizationPrivileges

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiUpdateOrganizationPrivilegesRequest
*/
func (a *AccessApiAPIService) UpdateOrganizationPrivileges(ctx context.Context) ApiUpdateOrganizationPrivilegesRequest {
	return ApiUpdateOrganizationPrivilegesRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return OrganizationAccessResponse
func (a *AccessApiAPIService) UpdateOrganizationPrivilegesExecute(r ApiUpdateOrganizationPrivilegesRequest) (*OrganizationAccessResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPost
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *OrganizationAccessResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.UpdateOrganizationPrivileges")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/organization"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.updateOrganizationPrivilegesRequest == nil {
		return localVarReturnValue, nil, reportError("updateOrganizationPrivilegesRequest 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"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "simple", "")
	}
	// body params
	localVarPostBody = r.updateOrganizationPrivilegesRequest
	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,
		}
		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 ApiUpdateServicePrivilegesRequest struct {
	ctx                            context.Context
	ApiService                     AccessApiAPI
	updateServicePrivilegesRequest *UpdateServicePrivilegesRequest
	authorization                  *string
	dPoP                           *string
}

func (r ApiUpdateServicePrivilegesRequest) UpdateServicePrivilegesRequest(updateServicePrivilegesRequest UpdateServicePrivilegesRequest) ApiUpdateServicePrivilegesRequest {
	r.updateServicePrivilegesRequest = &updateServicePrivilegesRequest
	return r
}

func (r ApiUpdateServicePrivilegesRequest) Authorization(authorization string) ApiUpdateServicePrivilegesRequest {
	r.authorization = &authorization
	return r
}

func (r ApiUpdateServicePrivilegesRequest) DPoP(dPoP string) ApiUpdateServicePrivilegesRequest {
	r.dPoP = &dPoP
	return r
}

func (r ApiUpdateServicePrivilegesRequest) Execute() (*ServiceAccessResponse, *http.Response, error) {
	return r.ApiService.UpdateServicePrivilegesExecute(r)
}

/*
UpdateServicePrivileges Method for UpdateServicePrivileges

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiUpdateServicePrivilegesRequest
*/
func (a *AccessApiAPIService) UpdateServicePrivileges(ctx context.Context) ApiUpdateServicePrivilegesRequest {
	return ApiUpdateServicePrivilegesRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return ServiceAccessResponse
func (a *AccessApiAPIService) UpdateServicePrivilegesExecute(r ApiUpdateServicePrivilegesRequest) (*ServiceAccessResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPost
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *ServiceAccessResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "AccessApiAPIService.UpdateServicePrivileges")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/access/service"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.updateServicePrivilegesRequest == nil {
		return localVarReturnValue, nil, reportError("updateServicePrivilegesRequest 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"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.authorization != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "Authorization", r.authorization, "simple", "")
	}
	if r.dPoP != nil {
		parameterAddToHeaderOrQuery(localVarHeaderParams, "DPoP", r.dPoP, "simple", "")
	}
	// body params
	localVarPostBody = r.updateServicePrivilegesRequest
	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,
		}
		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
}