api_identity_providers.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"
)

// IdentityProvidersAPIService IdentityProvidersAPI service
type IdentityProvidersAPIService service

type ApiAdminRealmsRealmIdentityProviderImportConfigPostRequest struct {
	ctx         context.Context
	ApiService  *IdentityProvidersAPIService
	realm       string
	requestBody *map[string]interface{}
}

func (r ApiAdminRealmsRealmIdentityProviderImportConfigPostRequest) RequestBody(requestBody map[string]interface{}) ApiAdminRealmsRealmIdentityProviderImportConfigPostRequest {
	r.requestBody = &requestBody
	return r
}

func (r ApiAdminRealmsRealmIdentityProviderImportConfigPostRequest) Execute() (map[string]string, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderImportConfigPostExecute(r)
}

/*
AdminRealmsRealmIdentityProviderImportConfigPost Import identity provider from JSON body

Import identity provider from uploaded JSON file

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

// Execute executes the request
//
//	@return	map[string]string
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderImportConfigPostExecute(r ApiAdminRealmsRealmIdentityProviderImportConfigPostRequest) (map[string]string, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPost
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue map[string]string
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/import-config"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -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{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.requestBody
	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 ApiAdminRealmsRealmIdentityProviderInstancesAliasDeleteRequest struct {
	ctx        context.Context
	ApiService *IdentityProvidersAPIService
	realm      string
	alias      string
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasDeleteRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasDeleteExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasDelete Delete the identity provider

	@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 alias
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasDeleteRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasDelete(ctx context.Context, realm string, alias string) ApiAdminRealmsRealmIdentityProviderInstancesAliasDeleteRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasDeleteRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -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 ApiAdminRealmsRealmIdentityProviderInstancesAliasExportGetRequest struct {
	ctx        context.Context
	ApiService *IdentityProvidersAPIService
	realm      string
	alias      string
	format     *string
}

// Format to use
func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasExportGetRequest) Format(format string) ApiAdminRealmsRealmIdentityProviderInstancesAliasExportGetRequest {
	r.format = &format
	return r
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasExportGetRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasExportGetExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasExportGet Export public broker configuration for identity provider

	@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 alias
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasExportGetRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasExportGet(ctx context.Context, realm string, alias string) ApiAdminRealmsRealmIdentityProviderInstancesAliasExportGetRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasExportGetRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
	}
}

// Execute executes the request
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasExportGetExecute(r ApiAdminRealmsRealmIdentityProviderInstancesAliasExportGetRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodGet
		localVarPostBody   interface{}
		formFiles          []formFile
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}/export"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -1)

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

	if r.format != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "format", r.format, "form", "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{}

	// 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 ApiAdminRealmsRealmIdentityProviderInstancesAliasGetRequest struct {
	ctx        context.Context
	ApiService *IdentityProvidersAPIService
	realm      string
	alias      string
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasGetRequest) Execute() (*IdentityProviderRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasGetExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasGet Get the identity provider

	@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 alias
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasGetRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasGet(ctx context.Context, realm string, alias string) ApiAdminRealmsRealmIdentityProviderInstancesAliasGetRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasGetRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
	}
}

// Execute executes the request
//
//	@return	IdentityProviderRepresentation
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasGetExecute(r ApiAdminRealmsRealmIdentityProviderInstancesAliasGetRequest) (*IdentityProviderRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *IdentityProviderRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -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 ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGetRequest struct {
	ctx        context.Context
	ApiService *IdentityProvidersAPIService
	realm      string
	alias      string
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGetRequest) Execute() (*ManagementPermissionReference, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGetExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGet Return object stating whether client Authorization permissions have been initialized or not and a reference

	@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 alias
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGetRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGet(ctx context.Context, realm string, alias string) ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGetRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGetRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
	}
}

// Execute executes the request
//
//	@return	ManagementPermissionReference
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGetExecute(r ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGetRequest) (*ManagementPermissionReference, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *ManagementPermissionReference
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}/management/permissions"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -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 ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPutRequest struct {
	ctx                           context.Context
	ApiService                    *IdentityProvidersAPIService
	realm                         string
	alias                         string
	managementPermissionReference *ManagementPermissionReference
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPutRequest) ManagementPermissionReference(managementPermissionReference ManagementPermissionReference) ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPutRequest {
	r.managementPermissionReference = &managementPermissionReference
	return r
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPutRequest) Execute() (*ManagementPermissionReference, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPutExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPut Return object stating whether client Authorization permissions have been initialized or not and a reference

	@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 alias
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPutRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPut(ctx context.Context, realm string, alias string) ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPutRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPutRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
	}
}

// Execute executes the request
//
//	@return	ManagementPermissionReference
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPutExecute(r ApiAdminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPutRequest) (*ManagementPermissionReference, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPut
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *ManagementPermissionReference
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}/management/permissions"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -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{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.managementPermissionReference
	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 ApiAdminRealmsRealmIdentityProviderInstancesAliasMapperTypesGetRequest struct {
	ctx        context.Context
	ApiService *IdentityProvidersAPIService
	realm      string
	alias      string
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasMapperTypesGetRequest) Execute() (*map[string]IdentityProviderMapperTypeRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasMapperTypesGetExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasMapperTypesGet Get mapper types for identity provider

	@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 alias
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasMapperTypesGetRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasMapperTypesGet(ctx context.Context, realm string, alias string) ApiAdminRealmsRealmIdentityProviderInstancesAliasMapperTypesGetRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasMapperTypesGetRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
	}
}

// Execute executes the request
//
//	@return	map[string]IdentityProviderMapperTypeRepresentation
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasMapperTypesGetExecute(r ApiAdminRealmsRealmIdentityProviderInstancesAliasMapperTypesGetRequest) (*map[string]IdentityProviderMapperTypeRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *map[string]IdentityProviderMapperTypeRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}/mapper-types"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -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 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 ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersGetRequest struct {
	ctx        context.Context
	ApiService *IdentityProvidersAPIService
	realm      string
	alias      string
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersGetRequest) Execute() ([]IdentityProviderMapperRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasMappersGetExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasMappersGet Get mappers for identity provider

	@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 alias
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersGetRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasMappersGet(ctx context.Context, realm string, alias string) ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersGetRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersGetRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
	}
}

// Execute executes the request
//
//	@return	[]IdentityProviderMapperRepresentation
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasMappersGetExecute(r ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersGetRequest) ([]IdentityProviderMapperRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue []IdentityProviderMapperRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}/mappers"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -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 ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdDeleteRequest struct {
	ctx        context.Context
	ApiService *IdentityProvidersAPIService
	realm      string
	alias      string
	id         string
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdDeleteRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasMappersIdDeleteExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasMappersIdDelete Delete a mapper for the identity provider

	@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 alias
	@param id Mapper id
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdDeleteRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasMappersIdDelete(ctx context.Context, realm string, alias string, id string) ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdDeleteRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdDeleteRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
		id:         id,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}/mappers/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -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 ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdGetRequest struct {
	ctx        context.Context
	ApiService *IdentityProvidersAPIService
	realm      string
	alias      string
	id         string
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdGetRequest) Execute() (*IdentityProviderMapperRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasMappersIdGetExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasMappersIdGet Get mapper by id for the identity provider

	@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 alias
	@param id
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdGetRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasMappersIdGet(ctx context.Context, realm string, alias string, id string) ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdGetRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdGetRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
		id:         id,
	}
}

// Execute executes the request
//
//	@return	IdentityProviderMapperRepresentation
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasMappersIdGetExecute(r ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdGetRequest) (*IdentityProviderMapperRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *IdentityProviderMapperRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}/mappers/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -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 ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdPutRequest struct {
	ctx                                  context.Context
	ApiService                           *IdentityProvidersAPIService
	realm                                string
	alias                                string
	id                                   string
	identityProviderMapperRepresentation *IdentityProviderMapperRepresentation
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdPutRequest) IdentityProviderMapperRepresentation(identityProviderMapperRepresentation IdentityProviderMapperRepresentation) ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdPutRequest {
	r.identityProviderMapperRepresentation = &identityProviderMapperRepresentation
	return r
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdPutRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasMappersIdPutExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasMappersIdPut Update a mapper for the identity provider

	@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 alias
	@param id Mapper id
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdPutRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasMappersIdPut(ctx context.Context, realm string, alias string, id string) ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdPutRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersIdPutRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
		id:         id,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}/mappers/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -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.identityProviderMapperRepresentation
	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 ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersPostRequest struct {
	ctx                                  context.Context
	ApiService                           *IdentityProvidersAPIService
	realm                                string
	alias                                string
	identityProviderMapperRepresentation *IdentityProviderMapperRepresentation
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersPostRequest) IdentityProviderMapperRepresentation(identityProviderMapperRepresentation IdentityProviderMapperRepresentation) ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersPostRequest {
	r.identityProviderMapperRepresentation = &identityProviderMapperRepresentation
	return r
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersPostRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasMappersPostExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasMappersPost Add a mapper to identity provider

	@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 alias
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersPostRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasMappersPost(ctx context.Context, realm string, alias string) ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersPostRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasMappersPostRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}/mappers"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -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.identityProviderMapperRepresentation
	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 ApiAdminRealmsRealmIdentityProviderInstancesAliasPutRequest struct {
	ctx                            context.Context
	ApiService                     *IdentityProvidersAPIService
	realm                          string
	alias                          string
	identityProviderRepresentation *IdentityProviderRepresentation
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasPutRequest) IdentityProviderRepresentation(identityProviderRepresentation IdentityProviderRepresentation) ApiAdminRealmsRealmIdentityProviderInstancesAliasPutRequest {
	r.identityProviderRepresentation = &identityProviderRepresentation
	return r
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasPutRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasPutExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasPut Update the identity provider

	@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 alias
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasPutRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasPut(ctx context.Context, realm string, alias string) ApiAdminRealmsRealmIdentityProviderInstancesAliasPutRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasPutRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
	}
}

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -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.identityProviderRepresentation
	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 ApiAdminRealmsRealmIdentityProviderInstancesAliasReloadKeysGetRequest struct {
	ctx        context.Context
	ApiService *IdentityProvidersAPIService
	realm      string
	alias      string
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesAliasReloadKeysGetRequest) Execute() (bool, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesAliasReloadKeysGetExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesAliasReloadKeysGet Reaload keys for the identity provider if the provider supports it, \"true\" is returned if reload was performed, \"false\" if not.

	@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 alias
	@return ApiAdminRealmsRealmIdentityProviderInstancesAliasReloadKeysGetRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasReloadKeysGet(ctx context.Context, realm string, alias string) ApiAdminRealmsRealmIdentityProviderInstancesAliasReloadKeysGetRequest {
	return ApiAdminRealmsRealmIdentityProviderInstancesAliasReloadKeysGetRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		alias:      alias,
	}
}

// Execute executes the request
//
//	@return	bool
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesAliasReloadKeysGetExecute(r ApiAdminRealmsRealmIdentityProviderInstancesAliasReloadKeysGetRequest) (bool, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue bool
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances/{alias}/reload-keys"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"alias"+"}", url.PathEscape(parameterValueToString(r.alias, "alias")), -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 ApiAdminRealmsRealmIdentityProviderInstancesGetRequest struct {
	ctx                 context.Context
	ApiService          *IdentityProvidersAPIService
	realm               string
	briefRepresentation *bool
	first               *int32
	max                 *int32
	realmOnly           *bool
	search              *string
}

// Boolean which defines whether brief representations are returned (default: false)
func (r ApiAdminRealmsRealmIdentityProviderInstancesGetRequest) BriefRepresentation(briefRepresentation bool) ApiAdminRealmsRealmIdentityProviderInstancesGetRequest {
	r.briefRepresentation = &briefRepresentation
	return r
}

// Pagination offset
func (r ApiAdminRealmsRealmIdentityProviderInstancesGetRequest) First(first int32) ApiAdminRealmsRealmIdentityProviderInstancesGetRequest {
	r.first = &first
	return r
}

// Maximum results size (defaults to 100)
func (r ApiAdminRealmsRealmIdentityProviderInstancesGetRequest) Max(max int32) ApiAdminRealmsRealmIdentityProviderInstancesGetRequest {
	r.max = &max
	return r
}

// Boolean which defines if only realm-level IDPs (not associated with orgs) should be returned (default: false)
func (r ApiAdminRealmsRealmIdentityProviderInstancesGetRequest) RealmOnly(realmOnly bool) ApiAdminRealmsRealmIdentityProviderInstancesGetRequest {
	r.realmOnly = &realmOnly
	return r
}

// Filter specific providers by name. Search can be prefix (name*), contains (*name*) or exact (\"name\"). Default prefixed.
func (r ApiAdminRealmsRealmIdentityProviderInstancesGetRequest) Search(search string) ApiAdminRealmsRealmIdentityProviderInstancesGetRequest {
	r.search = &search
	return r
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesGetRequest) Execute() ([]IdentityProviderRepresentation, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesGetExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesGet List identity providers

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

// Execute executes the request
//
//	@return	[]IdentityProviderRepresentation
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderInstancesGetExecute(r ApiAdminRealmsRealmIdentityProviderInstancesGetRequest) ([]IdentityProviderRepresentation, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue []IdentityProviderRepresentation
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)

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

	if r.briefRepresentation != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "briefRepresentation", r.briefRepresentation, "form", "")
	}
	if r.first != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "first", r.first, "form", "")
	}
	if r.max != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "max", r.max, "form", "")
	}
	if r.realmOnly != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "realmOnly", r.realmOnly, "form", "")
	}
	if r.search != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "search", r.search, "form", "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// 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 ApiAdminRealmsRealmIdentityProviderInstancesPostRequest struct {
	ctx                            context.Context
	ApiService                     *IdentityProvidersAPIService
	realm                          string
	identityProviderRepresentation *IdentityProviderRepresentation
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesPostRequest) IdentityProviderRepresentation(identityProviderRepresentation IdentityProviderRepresentation) ApiAdminRealmsRealmIdentityProviderInstancesPostRequest {
	r.identityProviderRepresentation = &identityProviderRepresentation
	return r
}

func (r ApiAdminRealmsRealmIdentityProviderInstancesPostRequest) Execute() (*http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderInstancesPostExecute(r)
}

/*
AdminRealmsRealmIdentityProviderInstancesPost Create a new identity provider

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

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

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/instances"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -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.identityProviderRepresentation
	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 ApiAdminRealmsRealmIdentityProviderProvidersProviderIdGetRequest struct {
	ctx        context.Context
	ApiService *IdentityProvidersAPIService
	realm      string
	providerId string
}

func (r ApiAdminRealmsRealmIdentityProviderProvidersProviderIdGetRequest) Execute() (map[string]interface{}, *http.Response, error) {
	return r.ApiService.AdminRealmsRealmIdentityProviderProvidersProviderIdGetExecute(r)
}

/*
AdminRealmsRealmIdentityProviderProvidersProviderIdGet Get the identity provider factory for that provider 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 providerId The provider id to get the factory
	@return ApiAdminRealmsRealmIdentityProviderProvidersProviderIdGetRequest
*/
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderProvidersProviderIdGet(ctx context.Context, realm string, providerId string) ApiAdminRealmsRealmIdentityProviderProvidersProviderIdGetRequest {
	return ApiAdminRealmsRealmIdentityProviderProvidersProviderIdGetRequest{
		ApiService: a,
		ctx:        ctx,
		realm:      realm,
		providerId: providerId,
	}
}

// Execute executes the request
//
//	@return	map[string]interface{}
func (a *IdentityProvidersAPIService) AdminRealmsRealmIdentityProviderProvidersProviderIdGetExecute(r ApiAdminRealmsRealmIdentityProviderProvidersProviderIdGetRequest) (map[string]interface{}, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue map[string]interface{}
	)

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

	localVarPath := localBasePath + "/admin/realms/{realm}/identity-provider/providers/{provider_id}"
	localVarPath = strings.Replace(localVarPath, "{"+"realm"+"}", url.PathEscape(parameterValueToString(r.realm, "realm")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"provider_id"+"}", url.PathEscape(parameterValueToString(r.providerId, "providerId")), -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
}