/* 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 {
    ClientPoliciesRepresentation,
    ClientPoliciesRepresentationFromJSON,
    ClientPoliciesRepresentationToJSON,
    ClientProfilesRepresentation,
    ClientProfilesRepresentationFromJSON,
    ClientProfilesRepresentationToJSON,
    ClientRepresentation,
    ClientRepresentationFromJSON,
    ClientRepresentationToJSON,
    GlobalRequestResult,
    GlobalRequestResultFromJSON,
    GlobalRequestResultToJSON,
    GroupRepresentation,
    GroupRepresentationFromJSON,
    GroupRepresentationToJSON,
    ManagementPermissionReference,
    ManagementPermissionReferenceFromJSON,
    ManagementPermissionReferenceToJSON,
    PartialImportRepresentation,
    PartialImportRepresentationFromJSON,
    PartialImportRepresentationToJSON,
    RealmEventsConfigRepresentation,
    RealmEventsConfigRepresentationFromJSON,
    RealmEventsConfigRepresentationToJSON,
    RealmRepresentation,
    RealmRepresentationFromJSON,
    RealmRepresentationToJSON,
    TestLdapConnectionRepresentation,
    TestLdapConnectionRepresentationFromJSON,
    TestLdapConnectionRepresentationToJSON,
} from '../models';

export interface RealmAdminEventsDeleteRequest {
    realm: string;
}

export interface RealmAdminEventsGetRequest {
    realm: string;
    authClient?: string;
    authIpAddress?: string;
    authRealm?: string;
    authUser?: string;
    dateFrom?: string;
    dateTo?: string;
    first?: number;
    max?: number;
    operationTypes?: Array<string>;
    resourcePath?: string;
    resourceTypes?: Array<string>;
}

export interface RealmClearKeysCachePostRequest {
    realm: string;
}

export interface RealmClearRealmCachePostRequest {
    realm: string;
}

export interface RealmClearUserCachePostRequest {
    realm: string;
}

export interface RealmClientDescriptionConverterPostRequest {
    realm: string;
    body: string;
}

export interface RealmClientPoliciesPoliciesGetRequest {
    realm: string;
}

export interface RealmClientPoliciesPoliciesPutRequest {
    realm: string;
    clientPoliciesRepresentation: ClientPoliciesRepresentation;
}

export interface RealmClientPoliciesProfilesGetRequest {
    realm: string;
    includeGlobalProfiles?: boolean;
}

export interface RealmClientPoliciesProfilesPutRequest {
    realm: string;
    clientProfilesRepresentation: ClientProfilesRepresentation;
}

export interface RealmClientSessionStatsGetRequest {
    realm: string;
}

export interface RealmCredentialRegistratorsGetRequest {
    realm: string;
}

export interface RealmDefaultDefaultClientScopesClientScopeIdDeleteRequest {
    realm: string;
    clientScopeId: string;
}

export interface RealmDefaultDefaultClientScopesClientScopeIdPutRequest {
    realm: string;
    clientScopeId: string;
}

export interface RealmDefaultDefaultClientScopesGetRequest {
    realm: string;
}

export interface RealmDefaultGroupsGetRequest {
    realm: string;
}

export interface RealmDefaultGroupsGroupIdDeleteRequest {
    realm: string;
    groupId: string;
}

export interface RealmDefaultGroupsGroupIdPutRequest {
    realm: string;
    groupId: string;
}

export interface RealmDefaultOptionalClientScopesClientScopeIdDeleteRequest {
    realm: string;
    clientScopeId: string;
}

export interface RealmDefaultOptionalClientScopesClientScopeIdPutRequest {
    realm: string;
    clientScopeId: string;
}

export interface RealmDefaultOptionalClientScopesGetRequest {
    realm: string;
}

export interface RealmDeleteRequest {
    realm: string;
}

export interface RealmEventsConfigGetRequest {
    realm: string;
}

export interface RealmEventsConfigPutRequest {
    realm: string;
    realmEventsConfigRepresentation: RealmEventsConfigRepresentation;
}

export interface RealmEventsDeleteRequest {
    realm: string;
}

export interface RealmEventsGetRequest {
    realm: string;
    client?: string;
    dateFrom?: string;
    dateTo?: string;
    first?: number;
    ipAddress?: string;
    max?: number;
    type?: Array<string>;
    user?: string;
}

export interface RealmGetRequest {
    realm: string;
}

export interface RealmGroupByPathPathGetRequest {
    realm: string;
    path: string;
}

export interface RealmLdapServerCapabilitiesPostRequest {
    realm: string;
    testLdapConnectionRepresentation: TestLdapConnectionRepresentation;
}

export interface RealmLocalizationGetRequest {
    realm: string;
}

export interface RealmLocalizationLocaleDeleteRequest {
    realm: string;
    locale: string;
}

export interface RealmLocalizationLocaleGetRequest {
    realm: string;
    locale: string;
}

export interface RealmLocalizationLocaleKeyDeleteRequest {
    realm: string;
    locale: string;
    key: string;
}

export interface RealmLocalizationLocaleKeyGetRequest {
    realm: string;
    locale: string;
    key: string;
}

export interface RealmLocalizationLocaleKeyPutRequest {
    realm: string;
    locale: string;
    key: string;
    body: string;
}

export interface RealmLocalizationLocalePostRequest {
    realm: string;
    locale: string;
    requestBody: { [key: string]: object; };
}

export interface RealmLogoutAllPostRequest {
    realm: string;
}

export interface RealmPartialExportPostRequest {
    realm: string;
    exportClients?: boolean;
    exportGroupsAndRoles?: boolean;
}

export interface RealmPartialImportPostRequest {
    realm: string;
    partialImportRepresentation: PartialImportRepresentation;
}

export interface RealmPushRevocationPostRequest {
    realm: string;
}

export interface RealmPutRequest {
    realm: string;
    realmRepresentation: RealmRepresentation;
}

export interface RealmSessionsSessionDeleteRequest {
    realm: string;
    session: string;
}

export interface RealmTestLDAPConnectionPostRequest {
    realm: string;
    testLdapConnectionRepresentation: TestLdapConnectionRepresentation;
}

export interface RealmTestSMTPConnectionPostRequest {
    realm: string;
    requestBody: { [key: string]: object; };
}

export interface RealmUsersManagementPermissionsGetRequest {
    realm: string;
}

export interface RealmUsersManagementPermissionsPutRequest {
    realm: string;
    managementPermissionReference: ManagementPermissionReference;
}

export interface RootPostRequest {
    realmRepresentation: RealmRepresentation;
}

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

    /**
     * Delete all admin events
     */
    async realmAdminEventsDeleteRaw(requestParameters: RealmAdminEventsDeleteRequest): 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 realmAdminEventsDelete.');
        }

        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}/admin-events`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Delete all admin events
     */
    async realmAdminEventsDelete(requestParameters: RealmAdminEventsDeleteRequest): Promise<void> {
        await this.realmAdminEventsDeleteRaw(requestParameters);
    }

    /**
     * Get admin events   Returns all admin events, or filters events based on URL query parameters listed here
     */
    async realmAdminEventsGetRaw(requestParameters: RealmAdminEventsGetRequest): 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 realmAdminEventsGet.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        if (requestParameters.authClient !== undefined) {
            queryParameters['authClient'] = requestParameters.authClient;
        }

        if (requestParameters.authIpAddress !== undefined) {
            queryParameters['authIpAddress'] = requestParameters.authIpAddress;
        }

        if (requestParameters.authRealm !== undefined) {
            queryParameters['authRealm'] = requestParameters.authRealm;
        }

        if (requestParameters.authUser !== undefined) {
            queryParameters['authUser'] = requestParameters.authUser;
        }

        if (requestParameters.dateFrom !== undefined) {
            queryParameters['dateFrom'] = requestParameters.dateFrom;
        }

        if (requestParameters.dateTo !== undefined) {
            queryParameters['dateTo'] = requestParameters.dateTo;
        }

        if (requestParameters.first !== undefined) {
            queryParameters['first'] = requestParameters.first;
        }

        if (requestParameters.max !== undefined) {
            queryParameters['max'] = requestParameters.max;
        }

        if (requestParameters.operationTypes) {
            queryParameters['operationTypes'] = requestParameters.operationTypes;
        }

        if (requestParameters.resourcePath !== undefined) {
            queryParameters['resourcePath'] = requestParameters.resourcePath;
        }

        if (requestParameters.resourceTypes) {
            queryParameters['resourceTypes'] = requestParameters.resourceTypes;
        }

        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}/admin-events`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     * Get admin events   Returns all admin events, or filters events based on URL query parameters listed here
     */
    async realmAdminEventsGet(requestParameters: RealmAdminEventsGetRequest): Promise<Array<{ [key: string]: object; }>> {
        const response = await this.realmAdminEventsGetRaw(requestParameters);
        return await response.value();
    }

    /**
     * Clear cache of external public keys (Public keys of clients or Identity providers)
     */
    async realmClearKeysCachePostRaw(requestParameters: RealmClearKeysCachePostRequest): 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 realmClearKeysCachePost.');
        }

        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}/clear-keys-cache`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Clear cache of external public keys (Public keys of clients or Identity providers)
     */
    async realmClearKeysCachePost(requestParameters: RealmClearKeysCachePostRequest): Promise<void> {
        await this.realmClearKeysCachePostRaw(requestParameters);
    }

    /**
     * Clear realm cache
     */
    async realmClearRealmCachePostRaw(requestParameters: RealmClearRealmCachePostRequest): 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 realmClearRealmCachePost.');
        }

        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}/clear-realm-cache`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Clear realm cache
     */
    async realmClearRealmCachePost(requestParameters: RealmClearRealmCachePostRequest): Promise<void> {
        await this.realmClearRealmCachePostRaw(requestParameters);
    }

    /**
     * Clear user cache
     */
    async realmClearUserCachePostRaw(requestParameters: RealmClearUserCachePostRequest): 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 realmClearUserCachePost.');
        }

        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}/clear-user-cache`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Clear user cache
     */
    async realmClearUserCachePost(requestParameters: RealmClearUserCachePostRequest): Promise<void> {
        await this.realmClearUserCachePostRaw(requestParameters);
    }

    /**
     * Base path for importing clients under this realm.
     */
    async realmClientDescriptionConverterPostRaw(requestParameters: RealmClientDescriptionConverterPostRequest): Promise<runtime.ApiResponse<ClientRepresentation>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientDescriptionConverterPost.');
        }

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

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'text/plain';

        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-description-converter`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.body as any,
        });

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

    /**
     * Base path for importing clients under this realm.
     */
    async realmClientDescriptionConverterPost(requestParameters: RealmClientDescriptionConverterPostRequest): Promise<ClientRepresentation> {
        const response = await this.realmClientDescriptionConverterPostRaw(requestParameters);
        return await response.value();
    }

    /**
     */
    async realmClientPoliciesPoliciesGetRaw(requestParameters: RealmClientPoliciesPoliciesGetRequest): Promise<runtime.ApiResponse<ClientPoliciesRepresentation>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientPoliciesPoliciesGet.');
        }

        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-policies/policies`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     */
    async realmClientPoliciesPoliciesGet(requestParameters: RealmClientPoliciesPoliciesGetRequest): Promise<ClientPoliciesRepresentation> {
        const response = await this.realmClientPoliciesPoliciesGetRaw(requestParameters);
        return await response.value();
    }

    /**
     */
    async realmClientPoliciesPoliciesPutRaw(requestParameters: RealmClientPoliciesPoliciesPutRequest): 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 realmClientPoliciesPoliciesPut.');
        }

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

        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-policies/policies`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ClientPoliciesRepresentationToJSON(requestParameters.clientPoliciesRepresentation),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmClientPoliciesPoliciesPut(requestParameters: RealmClientPoliciesPoliciesPutRequest): Promise<void> {
        await this.realmClientPoliciesPoliciesPutRaw(requestParameters);
    }

    /**
     */
    async realmClientPoliciesProfilesGetRaw(requestParameters: RealmClientPoliciesProfilesGetRequest): Promise<runtime.ApiResponse<ClientProfilesRepresentation>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientPoliciesProfilesGet.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        if (requestParameters.includeGlobalProfiles !== undefined) {
            queryParameters['include-global-profiles'] = requestParameters.includeGlobalProfiles;
        }

        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-policies/profiles`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     */
    async realmClientPoliciesProfilesGet(requestParameters: RealmClientPoliciesProfilesGetRequest): Promise<ClientProfilesRepresentation> {
        const response = await this.realmClientPoliciesProfilesGetRaw(requestParameters);
        return await response.value();
    }

    /**
     */
    async realmClientPoliciesProfilesPutRaw(requestParameters: RealmClientPoliciesProfilesPutRequest): 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 realmClientPoliciesProfilesPut.');
        }

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

        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-policies/profiles`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ClientProfilesRepresentationToJSON(requestParameters.clientProfilesRepresentation),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmClientPoliciesProfilesPut(requestParameters: RealmClientPoliciesProfilesPutRequest): Promise<void> {
        await this.realmClientPoliciesProfilesPutRaw(requestParameters);
    }

    /**
     * Get client session stats   Returns a JSON map.
     */
    async realmClientSessionStatsGetRaw(requestParameters: RealmClientSessionStatsGetRequest): 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 realmClientSessionStatsGet.');
        }

        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-session-stats`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     * Get client session stats   Returns a JSON map.
     */
    async realmClientSessionStatsGet(requestParameters: RealmClientSessionStatsGetRequest): Promise<Array<{ [key: string]: object; }>> {
        const response = await this.realmClientSessionStatsGetRaw(requestParameters);
        return await response.value();
    }

    /**
     */
    async realmCredentialRegistratorsGetRaw(requestParameters: RealmCredentialRegistratorsGetRequest): 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 realmCredentialRegistratorsGet.');
        }

        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}/credential-registrators`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     */
    async realmCredentialRegistratorsGet(requestParameters: RealmCredentialRegistratorsGetRequest): Promise<Array<{ [key: string]: object; }>> {
        const response = await this.realmCredentialRegistratorsGetRaw(requestParameters);
        return await response.value();
    }

    /**
     */
    async realmDefaultDefaultClientScopesClientScopeIdDeleteRaw(requestParameters: RealmDefaultDefaultClientScopesClientScopeIdDeleteRequest): 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 realmDefaultDefaultClientScopesClientScopeIdDelete.');
        }

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

        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}/default-default-client-scopes/{clientScopeId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"clientScopeId"}}`, encodeURIComponent(String(requestParameters.clientScopeId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmDefaultDefaultClientScopesClientScopeIdDelete(requestParameters: RealmDefaultDefaultClientScopesClientScopeIdDeleteRequest): Promise<void> {
        await this.realmDefaultDefaultClientScopesClientScopeIdDeleteRaw(requestParameters);
    }

    /**
     */
    async realmDefaultDefaultClientScopesClientScopeIdPutRaw(requestParameters: RealmDefaultDefaultClientScopesClientScopeIdPutRequest): 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 realmDefaultDefaultClientScopesClientScopeIdPut.');
        }

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

        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}/default-default-client-scopes/{clientScopeId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"clientScopeId"}}`, encodeURIComponent(String(requestParameters.clientScopeId))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmDefaultDefaultClientScopesClientScopeIdPut(requestParameters: RealmDefaultDefaultClientScopesClientScopeIdPutRequest): Promise<void> {
        await this.realmDefaultDefaultClientScopesClientScopeIdPutRaw(requestParameters);
    }

    /**
     * Get realm default client scopes.
     */
    async realmDefaultDefaultClientScopesGetRaw(requestParameters: RealmDefaultDefaultClientScopesGetRequest): 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 realmDefaultDefaultClientScopesGet.');
        }

        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}/default-default-client-scopes`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     * Get realm default client scopes.
     */
    async realmDefaultDefaultClientScopesGet(requestParameters: RealmDefaultDefaultClientScopesGetRequest): Promise<Array<{ [key: string]: object; }>> {
        const response = await this.realmDefaultDefaultClientScopesGetRaw(requestParameters);
        return await response.value();
    }

    /**
     * Get group hierarchy.
     */
    async realmDefaultGroupsGetRaw(requestParameters: RealmDefaultGroupsGetRequest): 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 realmDefaultGroupsGet.');
        }

        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}/default-groups`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     * Get group hierarchy.
     */
    async realmDefaultGroupsGet(requestParameters: RealmDefaultGroupsGetRequest): Promise<Array<{ [key: string]: object; }>> {
        const response = await this.realmDefaultGroupsGetRaw(requestParameters);
        return await response.value();
    }

    /**
     */
    async realmDefaultGroupsGroupIdDeleteRaw(requestParameters: RealmDefaultGroupsGroupIdDeleteRequest): 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 realmDefaultGroupsGroupIdDelete.');
        }

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

        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}/default-groups/{groupId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"groupId"}}`, encodeURIComponent(String(requestParameters.groupId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmDefaultGroupsGroupIdDelete(requestParameters: RealmDefaultGroupsGroupIdDeleteRequest): Promise<void> {
        await this.realmDefaultGroupsGroupIdDeleteRaw(requestParameters);
    }

    /**
     */
    async realmDefaultGroupsGroupIdPutRaw(requestParameters: RealmDefaultGroupsGroupIdPutRequest): 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 realmDefaultGroupsGroupIdPut.');
        }

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

        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}/default-groups/{groupId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"groupId"}}`, encodeURIComponent(String(requestParameters.groupId))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmDefaultGroupsGroupIdPut(requestParameters: RealmDefaultGroupsGroupIdPutRequest): Promise<void> {
        await this.realmDefaultGroupsGroupIdPutRaw(requestParameters);
    }

    /**
     */
    async realmDefaultOptionalClientScopesClientScopeIdDeleteRaw(requestParameters: RealmDefaultOptionalClientScopesClientScopeIdDeleteRequest): 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 realmDefaultOptionalClientScopesClientScopeIdDelete.');
        }

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

        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}/default-optional-client-scopes/{clientScopeId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"clientScopeId"}}`, encodeURIComponent(String(requestParameters.clientScopeId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmDefaultOptionalClientScopesClientScopeIdDelete(requestParameters: RealmDefaultOptionalClientScopesClientScopeIdDeleteRequest): Promise<void> {
        await this.realmDefaultOptionalClientScopesClientScopeIdDeleteRaw(requestParameters);
    }

    /**
     */
    async realmDefaultOptionalClientScopesClientScopeIdPutRaw(requestParameters: RealmDefaultOptionalClientScopesClientScopeIdPutRequest): 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 realmDefaultOptionalClientScopesClientScopeIdPut.');
        }

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

        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}/default-optional-client-scopes/{clientScopeId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"clientScopeId"}}`, encodeURIComponent(String(requestParameters.clientScopeId))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmDefaultOptionalClientScopesClientScopeIdPut(requestParameters: RealmDefaultOptionalClientScopesClientScopeIdPutRequest): Promise<void> {
        await this.realmDefaultOptionalClientScopesClientScopeIdPutRaw(requestParameters);
    }

    /**
     * Get realm optional client scopes.
     */
    async realmDefaultOptionalClientScopesGetRaw(requestParameters: RealmDefaultOptionalClientScopesGetRequest): 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 realmDefaultOptionalClientScopesGet.');
        }

        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}/default-optional-client-scopes`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     * Get realm optional client scopes.
     */
    async realmDefaultOptionalClientScopesGet(requestParameters: RealmDefaultOptionalClientScopesGetRequest): Promise<Array<{ [key: string]: object; }>> {
        const response = await this.realmDefaultOptionalClientScopesGetRaw(requestParameters);
        return await response.value();
    }

    /**
     * Delete the realm
     */
    async realmDeleteRaw(requestParameters: RealmDeleteRequest): 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 realmDelete.');
        }

        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}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Delete the realm
     */
    async realmDelete(requestParameters: RealmDeleteRequest): Promise<void> {
        await this.realmDeleteRaw(requestParameters);
    }

    /**
     * Get the events provider configuration   Returns JSON object with events provider configuration
     */
    async realmEventsConfigGetRaw(requestParameters: RealmEventsConfigGetRequest): Promise<runtime.ApiResponse<RealmEventsConfigRepresentation>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmEventsConfigGet.');
        }

        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}/events/config`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     * Get the events provider configuration   Returns JSON object with events provider configuration
     */
    async realmEventsConfigGet(requestParameters: RealmEventsConfigGetRequest): Promise<RealmEventsConfigRepresentation> {
        const response = await this.realmEventsConfigGetRaw(requestParameters);
        return await response.value();
    }

    /**
     * Update the events provider   Change the events provider and/or its configuration
     */
    async realmEventsConfigPutRaw(requestParameters: RealmEventsConfigPutRequest): 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 realmEventsConfigPut.');
        }

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

        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}/events/config`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: RealmEventsConfigRepresentationToJSON(requestParameters.realmEventsConfigRepresentation),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Update the events provider   Change the events provider and/or its configuration
     */
    async realmEventsConfigPut(requestParameters: RealmEventsConfigPutRequest): Promise<void> {
        await this.realmEventsConfigPutRaw(requestParameters);
    }

    /**
     * Delete all events
     */
    async realmEventsDeleteRaw(requestParameters: RealmEventsDeleteRequest): 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 realmEventsDelete.');
        }

        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}/events`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Delete all events
     */
    async realmEventsDelete(requestParameters: RealmEventsDeleteRequest): Promise<void> {
        await this.realmEventsDeleteRaw(requestParameters);
    }

    /**
     * Get events   Returns all events, or filters them based on URL query parameters listed here
     */
    async realmEventsGetRaw(requestParameters: RealmEventsGetRequest): 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 realmEventsGet.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        if (requestParameters.client !== undefined) {
            queryParameters['client'] = requestParameters.client;
        }

        if (requestParameters.dateFrom !== undefined) {
            queryParameters['dateFrom'] = requestParameters.dateFrom;
        }

        if (requestParameters.dateTo !== undefined) {
            queryParameters['dateTo'] = requestParameters.dateTo;
        }

        if (requestParameters.first !== undefined) {
            queryParameters['first'] = requestParameters.first;
        }

        if (requestParameters.ipAddress !== undefined) {
            queryParameters['ipAddress'] = requestParameters.ipAddress;
        }

        if (requestParameters.max !== undefined) {
            queryParameters['max'] = requestParameters.max;
        }

        if (requestParameters.type) {
            queryParameters['type'] = requestParameters.type;
        }

        if (requestParameters.user !== undefined) {
            queryParameters['user'] = requestParameters.user;
        }

        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}/events`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     * Get events   Returns all events, or filters them based on URL query parameters listed here
     */
    async realmEventsGet(requestParameters: RealmEventsGetRequest): Promise<Array<{ [key: string]: object; }>> {
        const response = await this.realmEventsGetRaw(requestParameters);
        return await response.value();
    }

    /**
     * Get the top-level representation of the realm   It will not include nested information like User and Client representations.
     */
    async realmGetRaw(requestParameters: RealmGetRequest): Promise<runtime.ApiResponse<RealmRepresentation>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmGet.');
        }

        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}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     * Get the top-level representation of the realm   It will not include nested information like User and Client representations.
     */
    async realmGet(requestParameters: RealmGetRequest): Promise<RealmRepresentation> {
        const response = await this.realmGetRaw(requestParameters);
        return await response.value();
    }

    /**
     */
    async realmGroupByPathPathGetRaw(requestParameters: RealmGroupByPathPathGetRequest): Promise<runtime.ApiResponse<GroupRepresentation>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmGroupByPathPathGet.');
        }

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

        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}/group-by-path/{path}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"path"}}`, encodeURIComponent(String(requestParameters.path))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     */
    async realmGroupByPathPathGet(requestParameters: RealmGroupByPathPathGetRequest): Promise<GroupRepresentation> {
        const response = await this.realmGroupByPathPathGetRaw(requestParameters);
        return await response.value();
    }

    /**
     * Get LDAP supported extensions.
     */
    async realmLdapServerCapabilitiesPostRaw(requestParameters: RealmLdapServerCapabilitiesPostRequest): 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 realmLdapServerCapabilitiesPost.');
        }

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

        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}/ldap-server-capabilities`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TestLdapConnectionRepresentationToJSON(requestParameters.testLdapConnectionRepresentation),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Get LDAP supported extensions.
     */
    async realmLdapServerCapabilitiesPost(requestParameters: RealmLdapServerCapabilitiesPostRequest): Promise<void> {
        await this.realmLdapServerCapabilitiesPostRaw(requestParameters);
    }

    /**
     */
    async realmLocalizationGetRaw(requestParameters: RealmLocalizationGetRequest): 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 realmLocalizationGet.');
        }

        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}/localization`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     */
    async realmLocalizationGet(requestParameters: RealmLocalizationGetRequest): Promise<Array<{ [key: string]: object; }>> {
        const response = await this.realmLocalizationGetRaw(requestParameters);
        return await response.value();
    }

    /**
     */
    async realmLocalizationLocaleDeleteRaw(requestParameters: RealmLocalizationLocaleDeleteRequest): 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 realmLocalizationLocaleDelete.');
        }

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

        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}/localization/{locale}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"locale"}}`, encodeURIComponent(String(requestParameters.locale))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmLocalizationLocaleDelete(requestParameters: RealmLocalizationLocaleDeleteRequest): Promise<void> {
        await this.realmLocalizationLocaleDeleteRaw(requestParameters);
    }

    /**
     */
    async realmLocalizationLocaleGetRaw(requestParameters: RealmLocalizationLocaleGetRequest): Promise<runtime.ApiResponse<{ [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 realmLocalizationLocaleGet.');
        }

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

        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}/localization/{locale}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"locale"}}`, encodeURIComponent(String(requestParameters.locale))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     */
    async realmLocalizationLocaleGet(requestParameters: RealmLocalizationLocaleGetRequest): Promise<{ [key: string]: object; }> {
        const response = await this.realmLocalizationLocaleGetRaw(requestParameters);
        return await response.value();
    }

    /**
     */
    async realmLocalizationLocaleKeyDeleteRaw(requestParameters: RealmLocalizationLocaleKeyDeleteRequest): 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 realmLocalizationLocaleKeyDelete.');
        }

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

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

        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}/localization/{locale}/{key}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"locale"}}`, encodeURIComponent(String(requestParameters.locale))).replace(`{${"key"}}`, encodeURIComponent(String(requestParameters.key))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmLocalizationLocaleKeyDelete(requestParameters: RealmLocalizationLocaleKeyDeleteRequest): Promise<void> {
        await this.realmLocalizationLocaleKeyDeleteRaw(requestParameters);
    }

    /**
     */
    async realmLocalizationLocaleKeyGetRaw(requestParameters: RealmLocalizationLocaleKeyGetRequest): Promise<runtime.ApiResponse<string>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmLocalizationLocaleKeyGet.');
        }

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

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

        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}/localization/{locale}/{key}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"locale"}}`, encodeURIComponent(String(requestParameters.locale))).replace(`{${"key"}}`, encodeURIComponent(String(requestParameters.key))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.TextApiResponse(response) as any;
    }

    /**
     */
    async realmLocalizationLocaleKeyGet(requestParameters: RealmLocalizationLocaleKeyGetRequest): Promise<string> {
        const response = await this.realmLocalizationLocaleKeyGetRaw(requestParameters);
        return await response.value();
    }

    /**
     */
    async realmLocalizationLocaleKeyPutRaw(requestParameters: RealmLocalizationLocaleKeyPutRequest): 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 realmLocalizationLocaleKeyPut.');
        }

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

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

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

        const queryParameters: runtime.HTTPQuery = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'text/plain';

        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}/localization/{locale}/{key}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"locale"}}`, encodeURIComponent(String(requestParameters.locale))).replace(`{${"key"}}`, encodeURIComponent(String(requestParameters.key))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.body as any,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmLocalizationLocaleKeyPut(requestParameters: RealmLocalizationLocaleKeyPutRequest): Promise<void> {
        await this.realmLocalizationLocaleKeyPutRaw(requestParameters);
    }

    /**
     */
    async realmLocalizationLocalePostRaw(requestParameters: RealmLocalizationLocalePostRequest): 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 realmLocalizationLocalePost.');
        }

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

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

        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}/localization/{locale}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"locale"}}`, encodeURIComponent(String(requestParameters.locale))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.requestBody,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmLocalizationLocalePost(requestParameters: RealmLocalizationLocalePostRequest): Promise<void> {
        await this.realmLocalizationLocalePostRaw(requestParameters);
    }

    /**
     * Removes all user sessions.
     */
    async realmLogoutAllPostRaw(requestParameters: RealmLogoutAllPostRequest): Promise<runtime.ApiResponse<GlobalRequestResult>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmLogoutAllPost.');
        }

        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}/logout-all`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     * Removes all user sessions.
     */
    async realmLogoutAllPost(requestParameters: RealmLogoutAllPostRequest): Promise<GlobalRequestResult> {
        const response = await this.realmLogoutAllPostRaw(requestParameters);
        return await response.value();
    }

    /**
     * Partial export of existing realm into a JSON file.
     */
    async realmPartialExportPostRaw(requestParameters: RealmPartialExportPostRequest): Promise<runtime.ApiResponse<RealmRepresentation>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmPartialExportPost.');
        }

        const queryParameters: runtime.HTTPQuery = {};

        if (requestParameters.exportClients !== undefined) {
            queryParameters['exportClients'] = requestParameters.exportClients;
        }

        if (requestParameters.exportGroupsAndRoles !== undefined) {
            queryParameters['exportGroupsAndRoles'] = requestParameters.exportGroupsAndRoles;
        }

        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}/partial-export`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     * Partial export of existing realm into a JSON file.
     */
    async realmPartialExportPost(requestParameters: RealmPartialExportPostRequest): Promise<RealmRepresentation> {
        const response = await this.realmPartialExportPostRaw(requestParameters);
        return await response.value();
    }

    /**
     * Partial import from a JSON file to an existing realm.
     */
    async realmPartialImportPostRaw(requestParameters: RealmPartialImportPostRequest): 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 realmPartialImportPost.');
        }

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

        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}/partialImport`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: PartialImportRepresentationToJSON(requestParameters.partialImportRepresentation),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Partial import from a JSON file to an existing realm.
     */
    async realmPartialImportPost(requestParameters: RealmPartialImportPostRequest): Promise<void> {
        await this.realmPartialImportPostRaw(requestParameters);
    }

    /**
     * Push the realm’s revocation policy to any client that has an admin url associated with it.
     */
    async realmPushRevocationPostRaw(requestParameters: RealmPushRevocationPostRequest): 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 realmPushRevocationPost.');
        }

        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}/push-revocation`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Push the realm’s revocation policy to any client that has an admin url associated with it.
     */
    async realmPushRevocationPost(requestParameters: RealmPushRevocationPostRequest): Promise<void> {
        await this.realmPushRevocationPostRaw(requestParameters);
    }

    /**
     * Update the top-level information of the realm   Any user, roles or client information in the representation  will be ignored.
     */
    async realmPutRaw(requestParameters: RealmPutRequest): 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 realmPut.');
        }

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

        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}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: RealmRepresentationToJSON(requestParameters.realmRepresentation),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Update the top-level information of the realm   Any user, roles or client information in the representation  will be ignored.
     */
    async realmPut(requestParameters: RealmPutRequest): Promise<void> {
        await this.realmPutRaw(requestParameters);
    }

    /**
     * Remove a specific user session.
     */
    async realmSessionsSessionDeleteRaw(requestParameters: RealmSessionsSessionDeleteRequest): 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 realmSessionsSessionDelete.');
        }

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

        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}/sessions/{session}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"session"}}`, encodeURIComponent(String(requestParameters.session))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Remove a specific user session.
     */
    async realmSessionsSessionDelete(requestParameters: RealmSessionsSessionDeleteRequest): Promise<void> {
        await this.realmSessionsSessionDeleteRaw(requestParameters);
    }

    /**
     * Test LDAP connection
     */
    async realmTestLDAPConnectionPostRaw(requestParameters: RealmTestLDAPConnectionPostRequest): 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 realmTestLDAPConnectionPost.');
        }

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

        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}/testLDAPConnection`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TestLdapConnectionRepresentationToJSON(requestParameters.testLdapConnectionRepresentation),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Test LDAP connection
     */
    async realmTestLDAPConnectionPost(requestParameters: RealmTestLDAPConnectionPostRequest): Promise<void> {
        await this.realmTestLDAPConnectionPostRaw(requestParameters);
    }

    /**
     */
    async realmTestSMTPConnectionPostRaw(requestParameters: RealmTestSMTPConnectionPostRequest): 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 realmTestSMTPConnectionPost.');
        }

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

        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}/testSMTPConnection`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.requestBody,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async realmTestSMTPConnectionPost(requestParameters: RealmTestSMTPConnectionPostRequest): Promise<void> {
        await this.realmTestSMTPConnectionPostRaw(requestParameters);
    }

    /**
     */
    async realmUsersManagementPermissionsGetRaw(requestParameters: RealmUsersManagementPermissionsGetRequest): Promise<runtime.ApiResponse<ManagementPermissionReference>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmUsersManagementPermissionsGet.');
        }

        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}/users-management-permissions`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

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

    /**
     */
    async realmUsersManagementPermissionsGet(requestParameters: RealmUsersManagementPermissionsGetRequest): Promise<ManagementPermissionReference> {
        const response = await this.realmUsersManagementPermissionsGetRaw(requestParameters);
        return await response.value();
    }

    /**
     */
    async realmUsersManagementPermissionsPutRaw(requestParameters: RealmUsersManagementPermissionsPutRequest): Promise<runtime.ApiResponse<ManagementPermissionReference>> {
        if (requestParameters.realm === null || requestParameters.realm === undefined) {
            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmUsersManagementPermissionsPut.');
        }

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

        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}/users-management-permissions`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ManagementPermissionReferenceToJSON(requestParameters.managementPermissionReference),
        });

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

    /**
     */
    async realmUsersManagementPermissionsPut(requestParameters: RealmUsersManagementPermissionsPutRequest): Promise<ManagementPermissionReference> {
        const response = await this.realmUsersManagementPermissionsPutRaw(requestParameters);
        return await response.value();
    }

    /**
     * Import a realm   Imports a realm from a full representation of that realm.
     */
    async rootPostRaw(requestParameters: RootPostRequest): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.realmRepresentation === null || requestParameters.realmRepresentation === undefined) {
            throw new runtime.RequiredError('realmRepresentation','Required parameter requestParameters.realmRepresentation was null or undefined when calling rootPost.');
        }

        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: `/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RealmRepresentationToJSON(requestParameters.realmRepresentation),
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Import a realm   Imports a realm from a full representation of that realm.
     */
    async rootPost(requestParameters: RootPostRequest): Promise<void> {
        await this.rootPostRaw(requestParameters);
    }

}