api_protocol_mappers.go

/*
Keycloak Admin REST API

This is a REST API reference for the Keycloak Admin REST API.

API version: 1.0
*/

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

package keycloak_admin_client

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

// ProtocolMappersAPIService ProtocolMappersAPI service
type ProtocolMappersAPIService service

type ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPostRequest struct {
	ctx                          context.Context
	ApiService                   *ProtocolMappersAPIService
	realm                        string
	clientScopeId                string
	protocolMapperRepresentation *[]ProtocolMapperRepresentation
}

func (r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPostRequest) ProtocolMapperRepresentation(protocolMapperRepresentation []ProtocolMapperRepresentation) ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPostRequest {
	r.protocolMapperRepresentation = &protocolMapperRepresentation
	return r
}

func (r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPostRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPostExecute(r)
}

/*
AdminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPost Create multiple mappers

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPostRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPost(ctx context.Context, realm string, clientScopeId string) ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPostRequest {
	return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPostRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/add-models"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// 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
	}
	// body params
	localVarPostBody = r.protocolMapperRepresentation
	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 ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGetRequest struct {
	ctx           context.Context
	ApiService    *ProtocolMappersAPIService
	realm         string
	clientScopeId string
}

func (r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGetRequest) Execute() ([]ProtocolMapperRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGetExecute(r)
}

/*
AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGet Get mappers

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGetRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGet(ctx context.Context, realm string, clientScopeId string) ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGetRequest {
	return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGetRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
	}
}

// Execute executes the request
//
//	@return	[]ProtocolMapperRepresentation
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGetExecute(r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGetRequest) ([]ProtocolMapperRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue []ProtocolMapperRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/models"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -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
	}
	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 ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDeleteRequest struct {
	ctx           context.Context
	ApiService    *ProtocolMappersAPIService
	realm         string
	clientScopeId string
	id            string
}

func (r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDeleteRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDeleteExecute(r)
}

/*
AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDelete Delete the mapper

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@param id Mapper id
	@return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDeleteRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDelete(ctx context.Context, realm string, clientScopeId string, id string) ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDeleteRequest {
	return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDeleteRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
		id:            id,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/models/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -1)
	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
	}
	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 ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGetRequest struct {
	ctx           context.Context
	ApiService    *ProtocolMappersAPIService
	realm         string
	clientScopeId string
	id            string
}

func (r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGetRequest) Execute() (*ProtocolMapperRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGetExecute(r)
}

/*
AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGet Get mapper by id

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@param id Mapper id
	@return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGetRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGet(ctx context.Context, realm string, clientScopeId string, id string) ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGetRequest {
	return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGetRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
		id:            id,
	}
}

// Execute executes the request
//
//	@return	ProtocolMapperRepresentation
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGetExecute(r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGetRequest) (*ProtocolMapperRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *ProtocolMapperRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/models/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -1)
	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
	}
	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 ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPutRequest struct {
	ctx                          context.Context
	ApiService                   *ProtocolMappersAPIService
	realm                        string
	clientScopeId                string
	id                           string
	protocolMapperRepresentation *ProtocolMapperRepresentation
}

func (r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPutRequest) ProtocolMapperRepresentation(protocolMapperRepresentation ProtocolMapperRepresentation) ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPutRequest {
	r.protocolMapperRepresentation = &protocolMapperRepresentation
	return r
}

func (r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPutRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPutExecute(r)
}

/*
AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPut Update the mapper

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@param id Mapper id
	@return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPutRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPut(ctx context.Context, realm string, clientScopeId string, id string) ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPutRequest {
	return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPutRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
		id:            id,
	}
}

// Execute executes the request
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPutExecute(r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPutRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodPut
		localVarPostBody   interface{}
		formFiles          []formFile
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/models/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -1)
	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{"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
	}
	// body params
	localVarPostBody = r.protocolMapperRepresentation
	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 ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPostRequest struct {
	ctx                          context.Context
	ApiService                   *ProtocolMappersAPIService
	realm                        string
	clientScopeId                string
	protocolMapperRepresentation *ProtocolMapperRepresentation
}

func (r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPostRequest) ProtocolMapperRepresentation(protocolMapperRepresentation ProtocolMapperRepresentation) ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPostRequest {
	r.protocolMapperRepresentation = &protocolMapperRepresentation
	return r
}

func (r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPostRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPostExecute(r)
}

/*
AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPost Create a mapper

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPostRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPost(ctx context.Context, realm string, clientScopeId string) ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPostRequest {
	return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPostRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/models"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// 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
	}
	// body params
	localVarPostBody = r.protocolMapperRepresentation
	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 ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGetRequest struct {
	ctx           context.Context
	ApiService    *ProtocolMappersAPIService
	realm         string
	clientScopeId string
	protocol      string
}

func (r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGetRequest) Execute() ([]ProtocolMapperRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGetExecute(r)
}

/*
AdminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGet Get mappers by name for a specific protocol

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@param protocol
	@return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGetRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGet(ctx context.Context, realm string, clientScopeId string, protocol string) ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGetRequest {
	return ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGetRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
		protocol:      protocol,
	}
}

// Execute executes the request
//
//	@return	[]ProtocolMapperRepresentation
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGetExecute(r ApiAdminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGetRequest) ([]ProtocolMapperRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue []ProtocolMapperRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/protocol/{protocol}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"protocol"+"}", url.PathEscape(parameterValueToString(r.protocol, "protocol")), -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
	}
	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 ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPostRequest struct {
	ctx                          context.Context
	ApiService                   *ProtocolMappersAPIService
	realm                        string
	clientScopeId                string
	protocolMapperRepresentation *[]ProtocolMapperRepresentation
}

func (r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPostRequest) ProtocolMapperRepresentation(protocolMapperRepresentation []ProtocolMapperRepresentation) ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPostRequest {
	r.protocolMapperRepresentation = &protocolMapperRepresentation
	return r
}

func (r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPostRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPostExecute(r)
}

/*
AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPost Create multiple mappers

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPostRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPost(ctx context.Context, realm string, clientScopeId string) ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPostRequest {
	return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPostRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/add-models"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// 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
	}
	// body params
	localVarPostBody = r.protocolMapperRepresentation
	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 ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGetRequest struct {
	ctx           context.Context
	ApiService    *ProtocolMappersAPIService
	realm         string
	clientScopeId string
}

func (r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGetRequest) Execute() ([]ProtocolMapperRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGetExecute(r)
}

/*
AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGet Get mappers

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGetRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGet(ctx context.Context, realm string, clientScopeId string) ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGetRequest {
	return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGetRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
	}
}

// Execute executes the request
//
//	@return	[]ProtocolMapperRepresentation
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGetExecute(r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGetRequest) ([]ProtocolMapperRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue []ProtocolMapperRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/models"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -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
	}
	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 ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDeleteRequest struct {
	ctx           context.Context
	ApiService    *ProtocolMappersAPIService
	realm         string
	clientScopeId string
	id            string
}

func (r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDeleteRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDeleteExecute(r)
}

/*
AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDelete Delete the mapper

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@param id Mapper id
	@return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDeleteRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDelete(ctx context.Context, realm string, clientScopeId string, id string) ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDeleteRequest {
	return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDeleteRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
		id:            id,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/models/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -1)
	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
	}
	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 ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGetRequest struct {
	ctx           context.Context
	ApiService    *ProtocolMappersAPIService
	realm         string
	clientScopeId string
	id            string
}

func (r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGetRequest) Execute() (*ProtocolMapperRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGetExecute(r)
}

/*
AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGet Get mapper by id

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@param id Mapper id
	@return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGetRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGet(ctx context.Context, realm string, clientScopeId string, id string) ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGetRequest {
	return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGetRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
		id:            id,
	}
}

// Execute executes the request
//
//	@return	ProtocolMapperRepresentation
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGetExecute(r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGetRequest) (*ProtocolMapperRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *ProtocolMapperRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/models/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -1)
	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
	}
	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 ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPutRequest struct {
	ctx                          context.Context
	ApiService                   *ProtocolMappersAPIService
	realm                        string
	clientScopeId                string
	id                           string
	protocolMapperRepresentation *ProtocolMapperRepresentation
}

func (r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPutRequest) ProtocolMapperRepresentation(protocolMapperRepresentation ProtocolMapperRepresentation) ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPutRequest {
	r.protocolMapperRepresentation = &protocolMapperRepresentation
	return r
}

func (r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPutRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPutExecute(r)
}

/*
AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPut Update the mapper

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@param id Mapper id
	@return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPutRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPut(ctx context.Context, realm string, clientScopeId string, id string) ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPutRequest {
	return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPutRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
		id:            id,
	}
}

// Execute executes the request
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPutExecute(r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPutRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodPut
		localVarPostBody   interface{}
		formFiles          []formFile
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/models/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -1)
	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{"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
	}
	// body params
	localVarPostBody = r.protocolMapperRepresentation
	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 ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPostRequest struct {
	ctx                          context.Context
	ApiService                   *ProtocolMappersAPIService
	realm                        string
	clientScopeId                string
	protocolMapperRepresentation *ProtocolMapperRepresentation
}

func (r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPostRequest) ProtocolMapperRepresentation(protocolMapperRepresentation ProtocolMapperRepresentation) ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPostRequest {
	r.protocolMapperRepresentation = &protocolMapperRepresentation
	return r
}

func (r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPostRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPostExecute(r)
}

/*
AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPost Create a mapper

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPostRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPost(ctx context.Context, realm string, clientScopeId string) ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPostRequest {
	return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPostRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/models"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// 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
	}
	// body params
	localVarPostBody = r.protocolMapperRepresentation
	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 ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGetRequest struct {
	ctx           context.Context
	ApiService    *ProtocolMappersAPIService
	realm         string
	clientScopeId string
	protocol      string
}

func (r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGetRequest) Execute() ([]ProtocolMapperRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGetExecute(r)
}

/*
AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGet Get mappers by name for a specific protocol

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientScopeId
	@param protocol
	@return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGetRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGet(ctx context.Context, realm string, clientScopeId string, protocol string) ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGetRequest {
	return ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGetRequest{
		ApiService:    a,
		ctx:           ctx,
		realm:         realm,
		clientScopeId: clientScopeId,
		protocol:      protocol,
	}
}

// Execute executes the request
//
//	@return	[]ProtocolMapperRepresentation
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGetExecute(r ApiAdminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGetRequest) ([]ProtocolMapperRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue []ProtocolMapperRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/protocol/{protocol}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-scope-id"+"}", url.PathEscape(parameterValueToString(r.clientScopeId, "clientScopeId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"protocol"+"}", url.PathEscape(parameterValueToString(r.protocol, "protocol")), -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
	}
	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 ApiAdminRealmsRealmClientsClientUuidProtocolMappersAddModelsPostRequest struct {
	ctx                          context.Context
	ApiService                   *ProtocolMappersAPIService
	realm                        string
	clientUuid                   string
	protocolMapperRepresentation *[]ProtocolMapperRepresentation
}

func (r ApiAdminRealmsRealmClientsClientUuidProtocolMappersAddModelsPostRequest) ProtocolMapperRepresentation(protocolMapperRepresentation []ProtocolMapperRepresentation) ApiAdminRealmsRealmClientsClientUuidProtocolMappersAddModelsPostRequest {
	r.protocolMapperRepresentation = &protocolMapperRepresentation
	return r
}

func (r ApiAdminRealmsRealmClientsClientUuidProtocolMappersAddModelsPostRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientsClientUuidProtocolMappersAddModelsPostExecute(r)
}

/*
AdminRealmsRealmClientsClientUuidProtocolMappersAddModelsPost Create multiple mappers

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientUuid id of client (not client-id!)
	@return ApiAdminRealmsRealmClientsClientUuidProtocolMappersAddModelsPostRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientsClientUuidProtocolMappersAddModelsPost(ctx context.Context, realm string, clientUuid string) ApiAdminRealmsRealmClientsClientUuidProtocolMappersAddModelsPostRequest {
	return ApiAdminRealmsRealmClientsClientUuidProtocolMappersAddModelsPostRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		clientUuid: clientUuid,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/add-models"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-uuid"+"}", url.PathEscape(parameterValueToString(r.clientUuid, "clientUuid")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// 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
	}
	// body params
	localVarPostBody = r.protocolMapperRepresentation
	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 ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsGetRequest struct {
	ctx        context.Context
	ApiService *ProtocolMappersAPIService
	realm      string
	clientUuid string
}

func (r ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsGetRequest) Execute() ([]ProtocolMapperRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientsClientUuidProtocolMappersModelsGetExecute(r)
}

/*
AdminRealmsRealmClientsClientUuidProtocolMappersModelsGet Get mappers

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientUuid id of client (not client-id!)
	@return ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsGetRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientsClientUuidProtocolMappersModelsGet(ctx context.Context, realm string, clientUuid string) ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsGetRequest {
	return ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsGetRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		clientUuid: clientUuid,
	}
}

// Execute executes the request
//
//	@return	[]ProtocolMapperRepresentation
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientsClientUuidProtocolMappersModelsGetExecute(r ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsGetRequest) ([]ProtocolMapperRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue []ProtocolMapperRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/models"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-uuid"+"}", url.PathEscape(parameterValueToString(r.clientUuid, "clientUuid")), -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
	}
	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 ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdDeleteRequest struct {
	ctx        context.Context
	ApiService *ProtocolMappersAPIService
	realm      string
	clientUuid string
	id         string
}

func (r ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdDeleteRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientsClientUuidProtocolMappersModelsIdDeleteExecute(r)
}

/*
AdminRealmsRealmClientsClientUuidProtocolMappersModelsIdDelete Delete the mapper

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientUuid id of client (not client-id!)
	@param id Mapper id
	@return ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdDeleteRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientsClientUuidProtocolMappersModelsIdDelete(ctx context.Context, realm string, clientUuid string, id string) ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdDeleteRequest {
	return ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdDeleteRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		clientUuid: clientUuid,
		id:         id,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/models/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-uuid"+"}", url.PathEscape(parameterValueToString(r.clientUuid, "clientUuid")), -1)
	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
	}
	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 ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdGetRequest struct {
	ctx        context.Context
	ApiService *ProtocolMappersAPIService
	realm      string
	clientUuid string
	id         string
}

func (r ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdGetRequest) Execute() (*ProtocolMapperRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientsClientUuidProtocolMappersModelsIdGetExecute(r)
}

/*
AdminRealmsRealmClientsClientUuidProtocolMappersModelsIdGet Get mapper by id

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientUuid id of client (not client-id!)
	@param id Mapper id
	@return ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdGetRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientsClientUuidProtocolMappersModelsIdGet(ctx context.Context, realm string, clientUuid string, id string) ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdGetRequest {
	return ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdGetRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		clientUuid: clientUuid,
		id:         id,
	}
}

// Execute executes the request
//
//	@return	ProtocolMapperRepresentation
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientsClientUuidProtocolMappersModelsIdGetExecute(r ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdGetRequest) (*ProtocolMapperRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *ProtocolMapperRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/models/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-uuid"+"}", url.PathEscape(parameterValueToString(r.clientUuid, "clientUuid")), -1)
	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
	}
	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 ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdPutRequest struct {
	ctx                          context.Context
	ApiService                   *ProtocolMappersAPIService
	realm                        string
	clientUuid                   string
	id                           string
	protocolMapperRepresentation *ProtocolMapperRepresentation
}

func (r ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdPutRequest) ProtocolMapperRepresentation(protocolMapperRepresentation ProtocolMapperRepresentation) ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdPutRequest {
	r.protocolMapperRepresentation = &protocolMapperRepresentation
	return r
}

func (r ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdPutRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientsClientUuidProtocolMappersModelsIdPutExecute(r)
}

/*
AdminRealmsRealmClientsClientUuidProtocolMappersModelsIdPut Update the mapper

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientUuid id of client (not client-id!)
	@param id Mapper id
	@return ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdPutRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientsClientUuidProtocolMappersModelsIdPut(ctx context.Context, realm string, clientUuid string, id string) ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdPutRequest {
	return ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdPutRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		clientUuid: clientUuid,
		id:         id,
	}
}

// Execute executes the request
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientsClientUuidProtocolMappersModelsIdPutExecute(r ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsIdPutRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodPut
		localVarPostBody   interface{}
		formFiles          []formFile
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/models/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-uuid"+"}", url.PathEscape(parameterValueToString(r.clientUuid, "clientUuid")), -1)
	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{"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
	}
	// body params
	localVarPostBody = r.protocolMapperRepresentation
	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 ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsPostRequest struct {
	ctx                          context.Context
	ApiService                   *ProtocolMappersAPIService
	realm                        string
	clientUuid                   string
	protocolMapperRepresentation *ProtocolMapperRepresentation
}

func (r ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsPostRequest) ProtocolMapperRepresentation(protocolMapperRepresentation ProtocolMapperRepresentation) ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsPostRequest {
	r.protocolMapperRepresentation = &protocolMapperRepresentation
	return r
}

func (r ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsPostRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientsClientUuidProtocolMappersModelsPostExecute(r)
}

/*
AdminRealmsRealmClientsClientUuidProtocolMappersModelsPost Create a mapper

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientUuid id of client (not client-id!)
	@return ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsPostRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientsClientUuidProtocolMappersModelsPost(ctx context.Context, realm string, clientUuid string) ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsPostRequest {
	return ApiAdminRealmsRealmClientsClientUuidProtocolMappersModelsPostRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		clientUuid: clientUuid,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/models"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-uuid"+"}", url.PathEscape(parameterValueToString(r.clientUuid, "clientUuid")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// 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
	}
	// body params
	localVarPostBody = r.protocolMapperRepresentation
	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 ApiAdminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGetRequest struct {
	ctx        context.Context
	ApiService *ProtocolMappersAPIService
	realm      string
	clientUuid string
	protocol   string
}

func (r ApiAdminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGetRequest) Execute() ([]ProtocolMapperRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGetExecute(r)
}

/*
AdminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGet Get mappers by name for a specific protocol

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param realm realm name (not id!)
	@param clientUuid id of client (not client-id!)
	@param protocol
	@return ApiAdminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGetRequest
*/
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGet(ctx context.Context, realm string, clientUuid string, protocol string) ApiAdminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGetRequest {
	return ApiAdminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGetRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		clientUuid: clientUuid,
		protocol:   protocol,
	}
}

// Execute executes the request
//
//	@return	[]ProtocolMapperRepresentation
func (a *ProtocolMappersAPIService) AdminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGetExecute(r ApiAdminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGetRequest) ([]ProtocolMapperRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue []ProtocolMapperRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/protocol/{protocol}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"client-uuid"+"}", url.PathEscape(parameterValueToString(r.clientUuid, "clientUuid")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"protocol"+"}", url.PathEscape(parameterValueToString(r.protocol, "protocol")), -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
	}
	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
}