/* tslint:disable */
/* eslint-disable */
/**
 * Keycloak Admin REST API
 * This is a REST API reference for the Keycloak Admin
 *
 * The version of the OpenAPI document: 1
 * 
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */


import * as runtime from '../runtime';
import {
    ProtocolMapperRepresentation,
    ProtocolMapperRepresentationFromJSON,
    ProtocolMapperRepresentationToJSON,
} from '../models';

export interface RealmClientScopesId1ProtocolMappersModelsId2DeleteRequest {
    realm: string;
    id1: string;
    id2: string;
}

export interface RealmClientScopesId1ProtocolMappersModelsId2GetRequest {
    realm: string;
    id1: string;
    id2: string;
}

export interface RealmClientScopesId1ProtocolMappersModelsId2PutRequest {
    realm: string;
    id1: string;
    id2: string;
    protocolMapperRepresentation: ProtocolMapperRepresentation;
}

export interface RealmClientScopesIdProtocolMappersAddModelsPostRequest {
    realm: string;
    id: string;
    protocolMapperRepresentation: Array<ProtocolMapperRepresentation>;
}

export interface RealmClientScopesIdProtocolMappersModelsGetRequest {
    realm: string;
    id: string;
}

export interface RealmClientScopesIdProtocolMappersModelsPostRequest {
    realm: string;
    id: string;
    protocolMapperRepresentation: ProtocolMapperRepresentation;
}

export interface RealmClientScopesIdProtocolMappersProtocolProtocolGetRequest {
    realm: string;
    id: string;
    protocol: string;
}

export interface RealmClientsId1ProtocolMappersModelsId2DeleteRequest {
    realm: string;
    id1: string;
    id2: string;
}

export interface RealmClientsId1ProtocolMappersModelsId2GetRequest {
    realm: string;
    id1: string;
    id2: string;
}

export interface RealmClientsId1ProtocolMappersModelsId2PutRequest {
    realm: string;
    id1: string;
    id2: string;
    protocolMapperRepresentation: ProtocolMapperRepresentation;
}

export interface RealmClientsIdProtocolMappersAddModelsPostRequest {
    realm: string;
    id: string;
    protocolMapperRepresentation: Array<ProtocolMapperRepresentation>;
}

export interface RealmClientsIdProtocolMappersModelsGetRequest {
    realm: string;
    id: string;
}

export interface RealmClientsIdProtocolMappersModelsPostRequest {
    realm: string;
    id: string;
    protocolMapperRepresentation: ProtocolMapperRepresentation;
}

export interface RealmClientsIdProtocolMappersProtocolProtocolGetRequest {
    realm: string;
    id: string;
    protocol: string;
}

/**
 * 
 */
export class ProtocolMappersApi extends runtime.BaseAPI {

    /**
     * Delete the mapper
     */
    async realmClientScopesId1ProtocolMappersModelsId2DeleteRaw(requestParameters: RealmClientScopesId1ProtocolMappersModelsId2DeleteRequest): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Delete.');
        }

        if (requestParameters.id1 === null || requestParameters.id1 === undefined) {
            throw new runtime.RequiredError('id1','Required parameter requestParameters.id1 was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Delete.');
        }

        if (requestParameters.id2 === null || requestParameters.id2 === undefined) {
            throw new runtime.RequiredError('id2','Required parameter requestParameters.id2 was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Delete.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/client-scopes/{id1}/protocol-mappers/models/{id2}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id1"}}`, encodeURIComponent(String(requestParameters.id1))).replace(`{${"id2"}}`, encodeURIComponent(String(requestParameters.id2))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Delete the mapper
     */
    async realmClientScopesId1ProtocolMappersModelsId2Delete(requestParameters: RealmClientScopesId1ProtocolMappersModelsId2DeleteRequest): Promise<void> {
        await this.realmClientScopesId1ProtocolMappersModelsId2DeleteRaw(requestParameters);
    }

    /**
     * Get mapper by id
     */
    async realmClientScopesId1ProtocolMappersModelsId2GetRaw(requestParameters: RealmClientScopesId1ProtocolMappersModelsId2GetRequest): Promise<runtime.ApiResponse<ProtocolMapperRepresentation>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Get.');
        }

        if (requestParameters.id1 === null || requestParameters.id1 === undefined) {
            throw new runtime.RequiredError('id1','Required parameter requestParameters.id1 was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Get.');
        }

        if (requestParameters.id2 === null || requestParameters.id2 === undefined) {
            throw new runtime.RequiredError('id2','Required parameter requestParameters.id2 was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Get.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/client-scopes/{id1}/protocol-mappers/models/{id2}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id1"}}`, encodeURIComponent(String(requestParameters.id1))).replace(`{${"id2"}}`, encodeURIComponent(String(requestParameters.id2))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.JSONApiResponse(response, (jsonValue) => ProtocolMapperRepresentationFromJSON(jsonValue));
    }

    /**
     * Get mapper by id
     */
    async realmClientScopesId1ProtocolMappersModelsId2Get(requestParameters: RealmClientScopesId1ProtocolMappersModelsId2GetRequest): Promise<ProtocolMapperRepresentation> {
        const response = await this.realmClientScopesId1ProtocolMappersModelsId2GetRaw(requestParameters);
        return await response.value();
    }

    /**
     * Update the mapper
     */
    async realmClientScopesId1ProtocolMappersModelsId2PutRaw(requestParameters: RealmClientScopesId1ProtocolMappersModelsId2PutRequest): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Put.');
        }

        if (requestParameters.id1 === null || requestParameters.id1 === undefined) {
            throw new runtime.RequiredError('id1','Required parameter requestParameters.id1 was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Put.');
        }

        if (requestParameters.id2 === null || requestParameters.id2 === undefined) {
            throw new runtime.RequiredError('id2','Required parameter requestParameters.id2 was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Put.');
        }

        if (requestParameters.protocolMapperRepresentation === null || requestParameters.protocolMapperRepresentation === undefined) {
            throw new runtime.RequiredError('protocolMapperRepresentation','Required parameter requestParameters.protocolMapperRepresentation was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Put.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/client-scopes/{id1}/protocol-mappers/models/{id2}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id1"}}`, encodeURIComponent(String(requestParameters.id1))).replace(`{${"id2"}}`, encodeURIComponent(String(requestParameters.id2))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ProtocolMapperRepresentationToJSON(requestParameters.protocolMapperRepresentation),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Update the mapper
     */
    async realmClientScopesId1ProtocolMappersModelsId2Put(requestParameters: RealmClientScopesId1ProtocolMappersModelsId2PutRequest): Promise<void> {
        await this.realmClientScopesId1ProtocolMappersModelsId2PutRaw(requestParameters);
    }

    /**
     * Create multiple mappers
     */
    async realmClientScopesIdProtocolMappersAddModelsPostRaw(requestParameters: RealmClientScopesIdProtocolMappersAddModelsPostRequest): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesIdProtocolMappersAddModelsPost.');
        }

        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientScopesIdProtocolMappersAddModelsPost.');
        }

        if (requestParameters.protocolMapperRepresentation === null || requestParameters.protocolMapperRepresentation === undefined) {
            throw new runtime.RequiredError('protocolMapperRepresentation','Required parameter requestParameters.protocolMapperRepresentation was null or undefined when calling realmClientScopesIdProtocolMappersAddModelsPost.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/client-scopes/{id}/protocol-mappers/add-models`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.protocolMapperRepresentation.map(ProtocolMapperRepresentationToJSON),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Create multiple mappers
     */
    async realmClientScopesIdProtocolMappersAddModelsPost(requestParameters: RealmClientScopesIdProtocolMappersAddModelsPostRequest): Promise<void> {
        await this.realmClientScopesIdProtocolMappersAddModelsPostRaw(requestParameters);
    }

    /**
     * Get mappers
     */
    async realmClientScopesIdProtocolMappersModelsGetRaw(requestParameters: RealmClientScopesIdProtocolMappersModelsGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesIdProtocolMappersModelsGet.');
        }

        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientScopesIdProtocolMappersModelsGet.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/client-scopes/{id}/protocol-mappers/models`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.JSONApiResponse<any>(response);
    }

    /**
     * Get mappers
     */
    async realmClientScopesIdProtocolMappersModelsGet(requestParameters: RealmClientScopesIdProtocolMappersModelsGetRequest): Promise<Array<{ [key: string]: object; }>> {
        const response = await this.realmClientScopesIdProtocolMappersModelsGetRaw(requestParameters);
        return await response.value();
    }

    /**
     * Create a mapper
     */
    async realmClientScopesIdProtocolMappersModelsPostRaw(requestParameters: RealmClientScopesIdProtocolMappersModelsPostRequest): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesIdProtocolMappersModelsPost.');
        }

        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientScopesIdProtocolMappersModelsPost.');
        }

        if (requestParameters.protocolMapperRepresentation === null || requestParameters.protocolMapperRepresentation === undefined) {
            throw new runtime.RequiredError('protocolMapperRepresentation','Required parameter requestParameters.protocolMapperRepresentation was null or undefined when calling realmClientScopesIdProtocolMappersModelsPost.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/client-scopes/{id}/protocol-mappers/models`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ProtocolMapperRepresentationToJSON(requestParameters.protocolMapperRepresentation),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Create a mapper
     */
    async realmClientScopesIdProtocolMappersModelsPost(requestParameters: RealmClientScopesIdProtocolMappersModelsPostRequest): Promise<void> {
        await this.realmClientScopesIdProtocolMappersModelsPostRaw(requestParameters);
    }

    /**
     * Get mappers by name for a specific protocol
     */
    async realmClientScopesIdProtocolMappersProtocolProtocolGetRaw(requestParameters: RealmClientScopesIdProtocolMappersProtocolProtocolGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesIdProtocolMappersProtocolProtocolGet.');
        }

        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientScopesIdProtocolMappersProtocolProtocolGet.');
        }

        if (requestParameters.protocol === null || requestParameters.protocol === undefined) {
            throw new runtime.RequiredError('protocol','Required parameter requestParameters.protocol was null or undefined when calling realmClientScopesIdProtocolMappersProtocolProtocolGet.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/client-scopes/{id}/protocol-mappers/protocol/{protocol}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"protocol"}}`, encodeURIComponent(String(requestParameters.protocol))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.JSONApiResponse<any>(response);
    }

    /**
     * Get mappers by name for a specific protocol
     */
    async realmClientScopesIdProtocolMappersProtocolProtocolGet(requestParameters: RealmClientScopesIdProtocolMappersProtocolProtocolGetRequest): Promise<Array<{ [key: string]: object; }>> {
        const response = await this.realmClientScopesIdProtocolMappersProtocolProtocolGetRaw(requestParameters);
        return await response.value();
    }

    /**
     * Delete the mapper
     */
    async realmClientsId1ProtocolMappersModelsId2DeleteRaw(requestParameters: RealmClientsId1ProtocolMappersModelsId2DeleteRequest): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Delete.');
        }

        if (requestParameters.id1 === null || requestParameters.id1 === undefined) {
            throw new runtime.RequiredError('id1','Required parameter requestParameters.id1 was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Delete.');
        }

        if (requestParameters.id2 === null || requestParameters.id2 === undefined) {
            throw new runtime.RequiredError('id2','Required parameter requestParameters.id2 was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Delete.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/clients/{id1}/protocol-mappers/models/{id2}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id1"}}`, encodeURIComponent(String(requestParameters.id1))).replace(`{${"id2"}}`, encodeURIComponent(String(requestParameters.id2))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Delete the mapper
     */
    async realmClientsId1ProtocolMappersModelsId2Delete(requestParameters: RealmClientsId1ProtocolMappersModelsId2DeleteRequest): Promise<void> {
        await this.realmClientsId1ProtocolMappersModelsId2DeleteRaw(requestParameters);
    }

    /**
     * Get mapper by id
     */
    async realmClientsId1ProtocolMappersModelsId2GetRaw(requestParameters: RealmClientsId1ProtocolMappersModelsId2GetRequest): Promise<runtime.ApiResponse<ProtocolMapperRepresentation>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Get.');
        }

        if (requestParameters.id1 === null || requestParameters.id1 === undefined) {
            throw new runtime.RequiredError('id1','Required parameter requestParameters.id1 was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Get.');
        }

        if (requestParameters.id2 === null || requestParameters.id2 === undefined) {
            throw new runtime.RequiredError('id2','Required parameter requestParameters.id2 was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Get.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/clients/{id1}/protocol-mappers/models/{id2}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id1"}}`, encodeURIComponent(String(requestParameters.id1))).replace(`{${"id2"}}`, encodeURIComponent(String(requestParameters.id2))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.JSONApiResponse(response, (jsonValue) => ProtocolMapperRepresentationFromJSON(jsonValue));
    }

    /**
     * Get mapper by id
     */
    async realmClientsId1ProtocolMappersModelsId2Get(requestParameters: RealmClientsId1ProtocolMappersModelsId2GetRequest): Promise<ProtocolMapperRepresentation> {
        const response = await this.realmClientsId1ProtocolMappersModelsId2GetRaw(requestParameters);
        return await response.value();
    }

    /**
     * Update the mapper
     */
    async realmClientsId1ProtocolMappersModelsId2PutRaw(requestParameters: RealmClientsId1ProtocolMappersModelsId2PutRequest): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Put.');
        }

        if (requestParameters.id1 === null || requestParameters.id1 === undefined) {
            throw new runtime.RequiredError('id1','Required parameter requestParameters.id1 was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Put.');
        }

        if (requestParameters.id2 === null || requestParameters.id2 === undefined) {
            throw new runtime.RequiredError('id2','Required parameter requestParameters.id2 was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Put.');
        }

        if (requestParameters.protocolMapperRepresentation === null || requestParameters.protocolMapperRepresentation === undefined) {
            throw new runtime.RequiredError('protocolMapperRepresentation','Required parameter requestParameters.protocolMapperRepresentation was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Put.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/clients/{id1}/protocol-mappers/models/{id2}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id1"}}`, encodeURIComponent(String(requestParameters.id1))).replace(`{${"id2"}}`, encodeURIComponent(String(requestParameters.id2))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ProtocolMapperRepresentationToJSON(requestParameters.protocolMapperRepresentation),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Update the mapper
     */
    async realmClientsId1ProtocolMappersModelsId2Put(requestParameters: RealmClientsId1ProtocolMappersModelsId2PutRequest): Promise<void> {
        await this.realmClientsId1ProtocolMappersModelsId2PutRaw(requestParameters);
    }

    /**
     * Create multiple mappers
     */
    async realmClientsIdProtocolMappersAddModelsPostRaw(requestParameters: RealmClientsIdProtocolMappersAddModelsPostRequest): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsIdProtocolMappersAddModelsPost.');
        }

        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdProtocolMappersAddModelsPost.');
        }

        if (requestParameters.protocolMapperRepresentation === null || requestParameters.protocolMapperRepresentation === undefined) {
            throw new runtime.RequiredError('protocolMapperRepresentation','Required parameter requestParameters.protocolMapperRepresentation was null or undefined when calling realmClientsIdProtocolMappersAddModelsPost.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/clients/{id}/protocol-mappers/add-models`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.protocolMapperRepresentation.map(ProtocolMapperRepresentationToJSON),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Create multiple mappers
     */
    async realmClientsIdProtocolMappersAddModelsPost(requestParameters: RealmClientsIdProtocolMappersAddModelsPostRequest): Promise<void> {
        await this.realmClientsIdProtocolMappersAddModelsPostRaw(requestParameters);
    }

    /**
     * Get mappers
     */
    async realmClientsIdProtocolMappersModelsGetRaw(requestParameters: RealmClientsIdProtocolMappersModelsGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsIdProtocolMappersModelsGet.');
        }

        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdProtocolMappersModelsGet.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/clients/{id}/protocol-mappers/models`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.JSONApiResponse<any>(response);
    }

    /**
     * Get mappers
     */
    async realmClientsIdProtocolMappersModelsGet(requestParameters: RealmClientsIdProtocolMappersModelsGetRequest): Promise<Array<{ [key: string]: object; }>> {
        const response = await this.realmClientsIdProtocolMappersModelsGetRaw(requestParameters);
        return await response.value();
    }

    /**
     * Create a mapper
     */
    async realmClientsIdProtocolMappersModelsPostRaw(requestParameters: RealmClientsIdProtocolMappersModelsPostRequest): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsIdProtocolMappersModelsPost.');
        }

        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdProtocolMappersModelsPost.');
        }

        if (requestParameters.protocolMapperRepresentation === null || requestParameters.protocolMapperRepresentation === undefined) {
            throw new runtime.RequiredError('protocolMapperRepresentation','Required parameter requestParameters.protocolMapperRepresentation was null or undefined when calling realmClientsIdProtocolMappersModelsPost.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/clients/{id}/protocol-mappers/models`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ProtocolMapperRepresentationToJSON(requestParameters.protocolMapperRepresentation),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Create a mapper
     */
    async realmClientsIdProtocolMappersModelsPost(requestParameters: RealmClientsIdProtocolMappersModelsPostRequest): Promise<void> {
        await this.realmClientsIdProtocolMappersModelsPostRaw(requestParameters);
    }

    /**
     * Get mappers by name for a specific protocol
     */
    async realmClientsIdProtocolMappersProtocolProtocolGetRaw(requestParameters: RealmClientsIdProtocolMappersProtocolProtocolGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsIdProtocolMappersProtocolProtocolGet.');
        }

        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdProtocolMappersProtocolProtocolGet.');
        }

        if (requestParameters.protocol === null || requestParameters.protocol === undefined) {
            throw new runtime.RequiredError('protocol','Required parameter requestParameters.protocol was null or undefined when calling realmClientsIdProtocolMappersProtocolProtocolGet.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = typeof token === 'function' ? token("access_token", []) : token;

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/{realm}/clients/{id}/protocol-mappers/protocol/{protocol}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"protocol"}}`, encodeURIComponent(String(requestParameters.protocol))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.JSONApiResponse<any>(response);
    }

    /**
     * Get mappers by name for a specific protocol
     */
    async realmClientsIdProtocolMappersProtocolProtocolGet(requestParameters: RealmClientsIdProtocolMappersProtocolProtocolGetRequest): Promise<Array<{ [key: string]: object; }>> {
        const response = await this.realmClientsIdProtocolMappersProtocolProtocolGetRaw(requestParameters);
        return await response.value();
    }

}