Switched kc_sdk to fetch

backend/keycloak/kc-client/apis/AttackDetectionApi.ts

@@ -0,0 +1,157 @@
+/* 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';
+
+export interface RealmAttackDetectionBruteForceUsersDeleteRequest {
+    realm: string;
+}
+
+export interface RealmAttackDetectionBruteForceUsersUserIdDeleteRequest {
+    realm: string;
+    userId: string;
+}
+
+export interface RealmAttackDetectionBruteForceUsersUserIdGetRequest {
+    realm: string;
+    userId: string;
+}
+
+/**
+ * 
+ */
+export class AttackDetectionApi extends runtime.BaseAPI {
+
+    /**
+     * Clear any user login failures for all users   This can release temporary disabled users
+     */
+    async realmAttackDetectionBruteForceUsersDeleteRaw(requestParameters: RealmAttackDetectionBruteForceUsersDeleteRequest): 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 realmAttackDetectionBruteForceUsersDelete.');
+        }
+
+        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}/attack-detection/brute-force/users`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Clear any user login failures for all users   This can release temporary disabled users
+     */
+    async realmAttackDetectionBruteForceUsersDelete(requestParameters: RealmAttackDetectionBruteForceUsersDeleteRequest): Promise<void> {
+        await this.realmAttackDetectionBruteForceUsersDeleteRaw(requestParameters);
+    }
+
+    /**
+     * Clear any user login failures for the user   This can release temporary disabled user
+     */
+    async realmAttackDetectionBruteForceUsersUserIdDeleteRaw(requestParameters: RealmAttackDetectionBruteForceUsersUserIdDeleteRequest): 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 realmAttackDetectionBruteForceUsersUserIdDelete.');
+        }
+
+        if (requestParameters.userId === null || requestParameters.userId === undefined) {
+            throw new runtime.RequiredError('userId','Required parameter requestParameters.userId was null or undefined when calling realmAttackDetectionBruteForceUsersUserIdDelete.');
+        }
+
+        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}/attack-detection/brute-force/users/{userId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters.userId))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Clear any user login failures for the user   This can release temporary disabled user
+     */
+    async realmAttackDetectionBruteForceUsersUserIdDelete(requestParameters: RealmAttackDetectionBruteForceUsersUserIdDeleteRequest): Promise<void> {
+        await this.realmAttackDetectionBruteForceUsersUserIdDeleteRaw(requestParameters);
+    }
+
+    /**
+     * Get status of a username in brute force detection
+     */
+    async realmAttackDetectionBruteForceUsersUserIdGetRaw(requestParameters: RealmAttackDetectionBruteForceUsersUserIdGetRequest): 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 realmAttackDetectionBruteForceUsersUserIdGet.');
+        }
+
+        if (requestParameters.userId === null || requestParameters.userId === undefined) {
+            throw new runtime.RequiredError('userId','Required parameter requestParameters.userId was null or undefined when calling realmAttackDetectionBruteForceUsersUserIdGet.');
+        }
+
+        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}/attack-detection/brute-force/users/{userId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters.userId))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get status of a username in brute force detection
+     */
+    async realmAttackDetectionBruteForceUsersUserIdGet(requestParameters: RealmAttackDetectionBruteForceUsersUserIdGetRequest): Promise<{ [key: string]: object; }> {
+        const response = await this.realmAttackDetectionBruteForceUsersUserIdGetRaw(requestParameters);
+        return await response.value();
+    }
+
+}

backend/keycloak/kc-client/apis/ClientAttributeCertificateApi.ts

@@ -0,0 +1,359 @@
+/* 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 {
+    CertificateRepresentation,
+    CertificateRepresentationFromJSON,
+    CertificateRepresentationToJSON,
+    KeyStoreConfig,
+    KeyStoreConfigFromJSON,
+    KeyStoreConfigToJSON,
+} from '../models';
+
+export interface RealmClientsIdCertificatesAttrDownloadPostRequest {
+    realm: string;
+    id: string;
+    attr: string;
+    keyStoreConfig: KeyStoreConfig;
+}
+
+export interface RealmClientsIdCertificatesAttrGenerateAndDownloadPostRequest {
+    realm: string;
+    id: string;
+    attr: string;
+    keyStoreConfig: KeyStoreConfig;
+}
+
+export interface RealmClientsIdCertificatesAttrGeneratePostRequest {
+    realm: string;
+    id: string;
+    attr: string;
+}
+
+export interface RealmClientsIdCertificatesAttrGetRequest {
+    realm: string;
+    id: string;
+    attr: string;
+}
+
+export interface RealmClientsIdCertificatesAttrUploadCertificatePostRequest {
+    realm: string;
+    id: string;
+    attr: string;
+}
+
+export interface RealmClientsIdCertificatesAttrUploadPostRequest {
+    realm: string;
+    id: string;
+    attr: string;
+}
+
+/**
+ * 
+ */
+export class ClientAttributeCertificateApi extends runtime.BaseAPI {
+
+    /**
+     * Get a keystore file for the client, containing private key and public certificate
+     */
+    async realmClientsIdCertificatesAttrDownloadPostRaw(requestParameters: RealmClientsIdCertificatesAttrDownloadPostRequest): 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 realmClientsIdCertificatesAttrDownloadPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdCertificatesAttrDownloadPost.');
+        }
+
+        if (requestParameters.attr === null || requestParameters.attr === undefined) {
+            throw new runtime.RequiredError('attr','Required parameter requestParameters.attr was null or undefined when calling realmClientsIdCertificatesAttrDownloadPost.');
+        }
+
+        if (requestParameters.keyStoreConfig === null || requestParameters.keyStoreConfig === undefined) {
+            throw new runtime.RequiredError('keyStoreConfig','Required parameter requestParameters.keyStoreConfig was null or undefined when calling realmClientsIdCertificatesAttrDownloadPost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id}/certificates/{attr}/download`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"attr"}}`, encodeURIComponent(String(requestParameters.attr))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: KeyStoreConfigToJSON(requestParameters.keyStoreConfig),
+        });
+
+        return new runtime.TextApiResponse(response) as any;
+    }
+
+    /**
+     * Get a keystore file for the client, containing private key and public certificate
+     */
+    async realmClientsIdCertificatesAttrDownloadPost(requestParameters: RealmClientsIdCertificatesAttrDownloadPostRequest): Promise<string> {
+        const response = await this.realmClientsIdCertificatesAttrDownloadPostRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Generate a new keypair and certificate, and get the private key file   Generates a keypair and certificate and serves the private key in a specified keystore format.
+     */
+    async realmClientsIdCertificatesAttrGenerateAndDownloadPostRaw(requestParameters: RealmClientsIdCertificatesAttrGenerateAndDownloadPostRequest): 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 realmClientsIdCertificatesAttrGenerateAndDownloadPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdCertificatesAttrGenerateAndDownloadPost.');
+        }
+
+        if (requestParameters.attr === null || requestParameters.attr === undefined) {
+            throw new runtime.RequiredError('attr','Required parameter requestParameters.attr was null or undefined when calling realmClientsIdCertificatesAttrGenerateAndDownloadPost.');
+        }
+
+        if (requestParameters.keyStoreConfig === null || requestParameters.keyStoreConfig === undefined) {
+            throw new runtime.RequiredError('keyStoreConfig','Required parameter requestParameters.keyStoreConfig was null or undefined when calling realmClientsIdCertificatesAttrGenerateAndDownloadPost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id}/certificates/{attr}/generate-and-download`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"attr"}}`, encodeURIComponent(String(requestParameters.attr))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: KeyStoreConfigToJSON(requestParameters.keyStoreConfig),
+        });
+
+        return new runtime.TextApiResponse(response) as any;
+    }
+
+    /**
+     * Generate a new keypair and certificate, and get the private key file   Generates a keypair and certificate and serves the private key in a specified keystore format.
+     */
+    async realmClientsIdCertificatesAttrGenerateAndDownloadPost(requestParameters: RealmClientsIdCertificatesAttrGenerateAndDownloadPostRequest): Promise<string> {
+        const response = await this.realmClientsIdCertificatesAttrGenerateAndDownloadPostRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Generate a new certificate with new key pair
+     */
+    async realmClientsIdCertificatesAttrGeneratePostRaw(requestParameters: RealmClientsIdCertificatesAttrGeneratePostRequest): Promise<runtime.ApiResponse<CertificateRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsIdCertificatesAttrGeneratePost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdCertificatesAttrGeneratePost.');
+        }
+
+        if (requestParameters.attr === null || requestParameters.attr === undefined) {
+            throw new runtime.RequiredError('attr','Required parameter requestParameters.attr was null or undefined when calling realmClientsIdCertificatesAttrGeneratePost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id}/certificates/{attr}/generate`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"attr"}}`, encodeURIComponent(String(requestParameters.attr))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Generate a new certificate with new key pair
+     */
+    async realmClientsIdCertificatesAttrGeneratePost(requestParameters: RealmClientsIdCertificatesAttrGeneratePostRequest): Promise<CertificateRepresentation> {
+        const response = await this.realmClientsIdCertificatesAttrGeneratePostRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Get key info
+     */
+    async realmClientsIdCertificatesAttrGetRaw(requestParameters: RealmClientsIdCertificatesAttrGetRequest): Promise<runtime.ApiResponse<CertificateRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsIdCertificatesAttrGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdCertificatesAttrGet.');
+        }
+
+        if (requestParameters.attr === null || requestParameters.attr === undefined) {
+            throw new runtime.RequiredError('attr','Required parameter requestParameters.attr was null or undefined when calling realmClientsIdCertificatesAttrGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id}/certificates/{attr}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"attr"}}`, encodeURIComponent(String(requestParameters.attr))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Get key info
+     */
+    async realmClientsIdCertificatesAttrGet(requestParameters: RealmClientsIdCertificatesAttrGetRequest): Promise<CertificateRepresentation> {
+        const response = await this.realmClientsIdCertificatesAttrGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Upload only certificate, not private key
+     */
+    async realmClientsIdCertificatesAttrUploadCertificatePostRaw(requestParameters: RealmClientsIdCertificatesAttrUploadCertificatePostRequest): Promise<runtime.ApiResponse<CertificateRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsIdCertificatesAttrUploadCertificatePost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdCertificatesAttrUploadCertificatePost.');
+        }
+
+        if (requestParameters.attr === null || requestParameters.attr === undefined) {
+            throw new runtime.RequiredError('attr','Required parameter requestParameters.attr was null or undefined when calling realmClientsIdCertificatesAttrUploadCertificatePost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id}/certificates/{attr}/upload-certificate`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"attr"}}`, encodeURIComponent(String(requestParameters.attr))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Upload only certificate, not private key
+     */
+    async realmClientsIdCertificatesAttrUploadCertificatePost(requestParameters: RealmClientsIdCertificatesAttrUploadCertificatePostRequest): Promise<CertificateRepresentation> {
+        const response = await this.realmClientsIdCertificatesAttrUploadCertificatePostRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Upload certificate and eventually private key
+     */
+    async realmClientsIdCertificatesAttrUploadPostRaw(requestParameters: RealmClientsIdCertificatesAttrUploadPostRequest): Promise<runtime.ApiResponse<CertificateRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsIdCertificatesAttrUploadPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdCertificatesAttrUploadPost.');
+        }
+
+        if (requestParameters.attr === null || requestParameters.attr === undefined) {
+            throw new runtime.RequiredError('attr','Required parameter requestParameters.attr was null or undefined when calling realmClientsIdCertificatesAttrUploadPost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id}/certificates/{attr}/upload`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"attr"}}`, encodeURIComponent(String(requestParameters.attr))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Upload certificate and eventually private key
+     */
+    async realmClientsIdCertificatesAttrUploadPost(requestParameters: RealmClientsIdCertificatesAttrUploadPostRequest): Promise<CertificateRepresentation> {
+        const response = await this.realmClientsIdCertificatesAttrUploadPostRaw(requestParameters);
+        return await response.value();
+    }
+
+}

backend/keycloak/kc-client/apis/ClientInitialAccessApi.ts

@@ -0,0 +1,165 @@
+/* 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 {
+    ClientInitialAccessCreatePresentation,
+    ClientInitialAccessCreatePresentationFromJSON,
+    ClientInitialAccessCreatePresentationToJSON,
+    ClientInitialAccessPresentation,
+    ClientInitialAccessPresentationFromJSON,
+    ClientInitialAccessPresentationToJSON,
+} from '../models';
+
+export interface RealmClientsInitialAccessGetRequest {
+    realm: string;
+}
+
+export interface RealmClientsInitialAccessIdDeleteRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmClientsInitialAccessPostRequest {
+    realm: string;
+    clientInitialAccessCreatePresentation: ClientInitialAccessCreatePresentation;
+}
+
+/**
+ * 
+ */
+export class ClientInitialAccessApi extends runtime.BaseAPI {
+
+    /**
+     */
+    async realmClientsInitialAccessGetRaw(requestParameters: RealmClientsInitialAccessGetRequest): 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 realmClientsInitialAccessGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients-initial-access`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     */
+    async realmClientsInitialAccessGet(requestParameters: RealmClientsInitialAccessGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmClientsInitialAccessGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     */
+    async realmClientsInitialAccessIdDeleteRaw(requestParameters: RealmClientsInitialAccessIdDeleteRequest): 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 realmClientsInitialAccessIdDelete.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsInitialAccessIdDelete.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients-initial-access/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async realmClientsInitialAccessIdDelete(requestParameters: RealmClientsInitialAccessIdDeleteRequest): Promise<void> {
+        await this.realmClientsInitialAccessIdDeleteRaw(requestParameters);
+    }
+
+    /**
+     * Create a new initial access token.
+     */
+    async realmClientsInitialAccessPostRaw(requestParameters: RealmClientsInitialAccessPostRequest): Promise<runtime.ApiResponse<ClientInitialAccessPresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsInitialAccessPost.');
+        }
+
+        if (requestParameters.clientInitialAccessCreatePresentation === null || requestParameters.clientInitialAccessCreatePresentation === undefined) {
+            throw new runtime.RequiredError('clientInitialAccessCreatePresentation','Required parameter requestParameters.clientInitialAccessCreatePresentation was null or undefined when calling realmClientsInitialAccessPost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients-initial-access`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ClientInitialAccessCreatePresentationToJSON(requestParameters.clientInitialAccessCreatePresentation),
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientInitialAccessPresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Create a new initial access token.
+     */
+    async realmClientsInitialAccessPost(requestParameters: RealmClientsInitialAccessPostRequest): Promise<ClientInitialAccessPresentation> {
+        const response = await this.realmClientsInitialAccessPostRaw(requestParameters);
+        return await response.value();
+    }
+
+}

backend/keycloak/kc-client/apis/ClientRegistrationPolicyApi.ts

@@ -0,0 +1,65 @@
+/* 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';
+
+export interface RealmClientRegistrationPolicyProvidersGetRequest {
+    realm: string;
+}
+
+/**
+ * 
+ */
+export class ClientRegistrationPolicyApi extends runtime.BaseAPI {
+
+    /**
+     * Base path for retrieve providers with the configProperties properly filled
+     */
+    async realmClientRegistrationPolicyProvidersGetRaw(requestParameters: RealmClientRegistrationPolicyProvidersGetRequest): 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 realmClientRegistrationPolicyProvidersGet.');
+        }
+
+        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-registration-policy/providers`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Base path for retrieve providers with the configProperties properly filled
+     */
+    async realmClientRegistrationPolicyProvidersGet(requestParameters: RealmClientRegistrationPolicyProvidersGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmClientRegistrationPolicyProvidersGetRaw(requestParameters);
+        return await response.value();
+    }
+
+}

backend/keycloak/kc-client/apis/ClientRoleMappingsApi.ts

@@ -0,0 +1,586 @@
+/* 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 {
+    RoleRepresentation,
+    RoleRepresentationFromJSON,
+    RoleRepresentationToJSON,
+} from '../models';
+
+export interface RealmGroupsIdRoleMappingsClientsClientAvailableGetRequest {
+    realm: string;
+    id: string;
+    client: string;
+}
+
+export interface RealmGroupsIdRoleMappingsClientsClientCompositeGetRequest {
+    realm: string;
+    id: string;
+    client: string;
+    briefRepresentation?: boolean;
+}
+
+export interface RealmGroupsIdRoleMappingsClientsClientDeleteRequest {
+    realm: string;
+    id: string;
+    client: string;
+    roleRepresentation: Array<RoleRepresentation>;
+}
+
+export interface RealmGroupsIdRoleMappingsClientsClientGetRequest {
+    realm: string;
+    id: string;
+    client: string;
+}
+
+export interface RealmGroupsIdRoleMappingsClientsClientPostRequest {
+    realm: string;
+    id: string;
+    client: string;
+    roleRepresentation: Array<RoleRepresentation>;
+}
+
+export interface RealmUsersIdRoleMappingsClientsClientAvailableGetRequest {
+    realm: string;
+    id: string;
+    client: string;
+}
+
+export interface RealmUsersIdRoleMappingsClientsClientCompositeGetRequest {
+    realm: string;
+    id: string;
+    client: string;
+    briefRepresentation?: boolean;
+}
+
+export interface RealmUsersIdRoleMappingsClientsClientDeleteRequest {
+    realm: string;
+    id: string;
+    client: string;
+    roleRepresentation: Array<RoleRepresentation>;
+}
+
+export interface RealmUsersIdRoleMappingsClientsClientGetRequest {
+    realm: string;
+    id: string;
+    client: string;
+}
+
+export interface RealmUsersIdRoleMappingsClientsClientPostRequest {
+    realm: string;
+    id: string;
+    client: string;
+    roleRepresentation: Array<RoleRepresentation>;
+}
+
+/**
+ * 
+ */
+export class ClientRoleMappingsApi extends runtime.BaseAPI {
+
+    /**
+     * Get available client-level roles that can be mapped to the user
+     */
+    async realmGroupsIdRoleMappingsClientsClientAvailableGetRaw(requestParameters: RealmGroupsIdRoleMappingsClientsClientAvailableGetRequest): 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 realmGroupsIdRoleMappingsClientsClientAvailableGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdRoleMappingsClientsClientAvailableGet.');
+        }
+
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling realmGroupsIdRoleMappingsClientsClientAvailableGet.');
+        }
+
+        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}/groups/{id}/role-mappings/clients/{client}/available`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"client"}}`, encodeURIComponent(String(requestParameters.client))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get available client-level roles that can be mapped to the user
+     */
+    async realmGroupsIdRoleMappingsClientsClientAvailableGet(requestParameters: RealmGroupsIdRoleMappingsClientsClientAvailableGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmGroupsIdRoleMappingsClientsClientAvailableGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Get effective client-level role mappings   This recurses any composite roles
+     */
+    async realmGroupsIdRoleMappingsClientsClientCompositeGetRaw(requestParameters: RealmGroupsIdRoleMappingsClientsClientCompositeGetRequest): 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 realmGroupsIdRoleMappingsClientsClientCompositeGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdRoleMappingsClientsClientCompositeGet.');
+        }
+
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling realmGroupsIdRoleMappingsClientsClientCompositeGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.briefRepresentation !== undefined) {
+            queryParameters['briefRepresentation'] = requestParameters.briefRepresentation;
+        }
+
+        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}/groups/{id}/role-mappings/clients/{client}/composite`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"client"}}`, encodeURIComponent(String(requestParameters.client))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get effective client-level role mappings   This recurses any composite roles
+     */
+    async realmGroupsIdRoleMappingsClientsClientCompositeGet(requestParameters: RealmGroupsIdRoleMappingsClientsClientCompositeGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmGroupsIdRoleMappingsClientsClientCompositeGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Delete client-level roles from user role mapping
+     */
+    async realmGroupsIdRoleMappingsClientsClientDeleteRaw(requestParameters: RealmGroupsIdRoleMappingsClientsClientDeleteRequest): 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 realmGroupsIdRoleMappingsClientsClientDelete.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdRoleMappingsClientsClientDelete.');
+        }
+
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling realmGroupsIdRoleMappingsClientsClientDelete.');
+        }
+
+        if (requestParameters.roleRepresentation === null || requestParameters.roleRepresentation === undefined) {
+            throw new runtime.RequiredError('roleRepresentation','Required parameter requestParameters.roleRepresentation was null or undefined when calling realmGroupsIdRoleMappingsClientsClientDelete.');
+        }
+
+        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}/groups/{id}/role-mappings/clients/{client}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"client"}}`, encodeURIComponent(String(requestParameters.client))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.roleRepresentation.map(RoleRepresentationToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete client-level roles from user role mapping
+     */
+    async realmGroupsIdRoleMappingsClientsClientDelete(requestParameters: RealmGroupsIdRoleMappingsClientsClientDeleteRequest): Promise<void> {
+        await this.realmGroupsIdRoleMappingsClientsClientDeleteRaw(requestParameters);
+    }
+
+    /**
+     * Get client-level role mappings for the user, and the app
+     */
+    async realmGroupsIdRoleMappingsClientsClientGetRaw(requestParameters: RealmGroupsIdRoleMappingsClientsClientGetRequest): 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 realmGroupsIdRoleMappingsClientsClientGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdRoleMappingsClientsClientGet.');
+        }
+
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling realmGroupsIdRoleMappingsClientsClientGet.');
+        }
+
+        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}/groups/{id}/role-mappings/clients/{client}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"client"}}`, encodeURIComponent(String(requestParameters.client))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get client-level role mappings for the user, and the app
+     */
+    async realmGroupsIdRoleMappingsClientsClientGet(requestParameters: RealmGroupsIdRoleMappingsClientsClientGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmGroupsIdRoleMappingsClientsClientGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Add client-level roles to the user role mapping
+     */
+    async realmGroupsIdRoleMappingsClientsClientPostRaw(requestParameters: RealmGroupsIdRoleMappingsClientsClientPostRequest): 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 realmGroupsIdRoleMappingsClientsClientPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdRoleMappingsClientsClientPost.');
+        }
+
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling realmGroupsIdRoleMappingsClientsClientPost.');
+        }
+
+        if (requestParameters.roleRepresentation === null || requestParameters.roleRepresentation === undefined) {
+            throw new runtime.RequiredError('roleRepresentation','Required parameter requestParameters.roleRepresentation was null or undefined when calling realmGroupsIdRoleMappingsClientsClientPost.');
+        }
+
+        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}/groups/{id}/role-mappings/clients/{client}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"client"}}`, encodeURIComponent(String(requestParameters.client))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.roleRepresentation.map(RoleRepresentationToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Add client-level roles to the user role mapping
+     */
+    async realmGroupsIdRoleMappingsClientsClientPost(requestParameters: RealmGroupsIdRoleMappingsClientsClientPostRequest): Promise<void> {
+        await this.realmGroupsIdRoleMappingsClientsClientPostRaw(requestParameters);
+    }
+
+    /**
+     * Get available client-level roles that can be mapped to the user
+     */
+    async realmUsersIdRoleMappingsClientsClientAvailableGetRaw(requestParameters: RealmUsersIdRoleMappingsClientsClientAvailableGetRequest): 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 realmUsersIdRoleMappingsClientsClientAvailableGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUsersIdRoleMappingsClientsClientAvailableGet.');
+        }
+
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling realmUsersIdRoleMappingsClientsClientAvailableGet.');
+        }
+
+        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/{id}/role-mappings/clients/{client}/available`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"client"}}`, encodeURIComponent(String(requestParameters.client))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get available client-level roles that can be mapped to the user
+     */
+    async realmUsersIdRoleMappingsClientsClientAvailableGet(requestParameters: RealmUsersIdRoleMappingsClientsClientAvailableGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmUsersIdRoleMappingsClientsClientAvailableGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Get effective client-level role mappings   This recurses any composite roles
+     */
+    async realmUsersIdRoleMappingsClientsClientCompositeGetRaw(requestParameters: RealmUsersIdRoleMappingsClientsClientCompositeGetRequest): 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 realmUsersIdRoleMappingsClientsClientCompositeGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUsersIdRoleMappingsClientsClientCompositeGet.');
+        }
+
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling realmUsersIdRoleMappingsClientsClientCompositeGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.briefRepresentation !== undefined) {
+            queryParameters['briefRepresentation'] = requestParameters.briefRepresentation;
+        }
+
+        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/{id}/role-mappings/clients/{client}/composite`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"client"}}`, encodeURIComponent(String(requestParameters.client))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get effective client-level role mappings   This recurses any composite roles
+     */
+    async realmUsersIdRoleMappingsClientsClientCompositeGet(requestParameters: RealmUsersIdRoleMappingsClientsClientCompositeGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmUsersIdRoleMappingsClientsClientCompositeGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Delete client-level roles from user role mapping
+     */
+    async realmUsersIdRoleMappingsClientsClientDeleteRaw(requestParameters: RealmUsersIdRoleMappingsClientsClientDeleteRequest): 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 realmUsersIdRoleMappingsClientsClientDelete.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUsersIdRoleMappingsClientsClientDelete.');
+        }
+
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling realmUsersIdRoleMappingsClientsClientDelete.');
+        }
+
+        if (requestParameters.roleRepresentation === null || requestParameters.roleRepresentation === undefined) {
+            throw new runtime.RequiredError('roleRepresentation','Required parameter requestParameters.roleRepresentation was null or undefined when calling realmUsersIdRoleMappingsClientsClientDelete.');
+        }
+
+        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/{id}/role-mappings/clients/{client}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"client"}}`, encodeURIComponent(String(requestParameters.client))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.roleRepresentation.map(RoleRepresentationToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete client-level roles from user role mapping
+     */
+    async realmUsersIdRoleMappingsClientsClientDelete(requestParameters: RealmUsersIdRoleMappingsClientsClientDeleteRequest): Promise<void> {
+        await this.realmUsersIdRoleMappingsClientsClientDeleteRaw(requestParameters);
+    }
+
+    /**
+     * Get client-level role mappings for the user, and the app
+     */
+    async realmUsersIdRoleMappingsClientsClientGetRaw(requestParameters: RealmUsersIdRoleMappingsClientsClientGetRequest): 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 realmUsersIdRoleMappingsClientsClientGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUsersIdRoleMappingsClientsClientGet.');
+        }
+
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling realmUsersIdRoleMappingsClientsClientGet.');
+        }
+
+        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/{id}/role-mappings/clients/{client}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"client"}}`, encodeURIComponent(String(requestParameters.client))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get client-level role mappings for the user, and the app
+     */
+    async realmUsersIdRoleMappingsClientsClientGet(requestParameters: RealmUsersIdRoleMappingsClientsClientGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmUsersIdRoleMappingsClientsClientGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Add client-level roles to the user role mapping
+     */
+    async realmUsersIdRoleMappingsClientsClientPostRaw(requestParameters: RealmUsersIdRoleMappingsClientsClientPostRequest): 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 realmUsersIdRoleMappingsClientsClientPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUsersIdRoleMappingsClientsClientPost.');
+        }
+
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling realmUsersIdRoleMappingsClientsClientPost.');
+        }
+
+        if (requestParameters.roleRepresentation === null || requestParameters.roleRepresentation === undefined) {
+            throw new runtime.RequiredError('roleRepresentation','Required parameter requestParameters.roleRepresentation was null or undefined when calling realmUsersIdRoleMappingsClientsClientPost.');
+        }
+
+        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/{id}/role-mappings/clients/{client}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"client"}}`, encodeURIComponent(String(requestParameters.client))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.roleRepresentation.map(RoleRepresentationToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Add client-level roles to the user role mapping
+     */
+    async realmUsersIdRoleMappingsClientsClientPost(requestParameters: RealmUsersIdRoleMappingsClientsClientPostRequest): Promise<void> {
+        await this.realmUsersIdRoleMappingsClientsClientPostRaw(requestParameters);
+    }
+
+}

backend/keycloak/kc-client/apis/ClientScopesApi.ts

@@ -0,0 +1,266 @@
+/* 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 {
+    ClientScopeRepresentation,
+    ClientScopeRepresentationFromJSON,
+    ClientScopeRepresentationToJSON,
+} from '../models';
+
+export interface RealmClientScopesGetRequest {
+    realm: string;
+}
+
+export interface RealmClientScopesIdDeleteRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmClientScopesIdGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmClientScopesIdPutRequest {
+    realm: string;
+    id: string;
+    clientScopeRepresentation: ClientScopeRepresentation;
+}
+
+export interface RealmClientScopesPostRequest {
+    realm: string;
+    clientScopeRepresentation: ClientScopeRepresentation;
+}
+
+/**
+ * 
+ */
+export class ClientScopesApi extends runtime.BaseAPI {
+
+    /**
+     * Get client scopes belonging to the realm   Returns a list of client scopes belonging to the realm
+     */
+    async realmClientScopesGetRaw(requestParameters: RealmClientScopesGetRequest): 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 realmClientScopesGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/client-scopes`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get client scopes belonging to the realm   Returns a list of client scopes belonging to the realm
+     */
+    async realmClientScopesGet(requestParameters: RealmClientScopesGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmClientScopesGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Delete the client scope
+     */
+    async realmClientScopesIdDeleteRaw(requestParameters: RealmClientScopesIdDeleteRequest): 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 realmClientScopesIdDelete.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientScopesIdDelete.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/client-scopes/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete the client scope
+     */
+    async realmClientScopesIdDelete(requestParameters: RealmClientScopesIdDeleteRequest): Promise<void> {
+        await this.realmClientScopesIdDeleteRaw(requestParameters);
+    }
+
+    /**
+     * Get representation of the client scope
+     */
+    async realmClientScopesIdGetRaw(requestParameters: RealmClientScopesIdGetRequest): Promise<runtime.ApiResponse<ClientScopeRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesIdGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientScopesIdGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/client-scopes/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientScopeRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Get representation of the client scope
+     */
+    async realmClientScopesIdGet(requestParameters: RealmClientScopesIdGetRequest): Promise<ClientScopeRepresentation> {
+        const response = await this.realmClientScopesIdGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Update the client scope
+     */
+    async realmClientScopesIdPutRaw(requestParameters: RealmClientScopesIdPutRequest): 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 realmClientScopesIdPut.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientScopesIdPut.');
+        }
+
+        if (requestParameters.clientScopeRepresentation === null || requestParameters.clientScopeRepresentation === undefined) {
+            throw new runtime.RequiredError('clientScopeRepresentation','Required parameter requestParameters.clientScopeRepresentation was null or undefined when calling realmClientScopesIdPut.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/client-scopes/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ClientScopeRepresentationToJSON(requestParameters.clientScopeRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Update the client scope
+     */
+    async realmClientScopesIdPut(requestParameters: RealmClientScopesIdPutRequest): Promise<void> {
+        await this.realmClientScopesIdPutRaw(requestParameters);
+    }
+
+    /**
+     * Create a new client scope   Client Scope’s name must be unique!
+     */
+    async realmClientScopesPostRaw(requestParameters: RealmClientScopesPostRequest): 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 realmClientScopesPost.');
+        }
+
+        if (requestParameters.clientScopeRepresentation === null || requestParameters.clientScopeRepresentation === undefined) {
+            throw new runtime.RequiredError('clientScopeRepresentation','Required parameter requestParameters.clientScopeRepresentation was null or undefined when calling realmClientScopesPost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/client-scopes`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ClientScopeRepresentationToJSON(requestParameters.clientScopeRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Create a new client scope   Client Scope’s name must be unique!
+     */
+    async realmClientScopesPost(requestParameters: RealmClientScopesPostRequest): Promise<void> {
+        await this.realmClientScopesPostRaw(requestParameters);
+    }
+
+}

backend/keycloak/kc-client/apis/ComponentApi.ts

@@ -0,0 +1,323 @@
+/* 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 {
+    ComponentRepresentation,
+    ComponentRepresentationFromJSON,
+    ComponentRepresentationToJSON,
+} from '../models';
+
+export interface RealmComponentsGetRequest {
+    realm: string;
+    name?: string;
+    parent?: string;
+    type?: string;
+}
+
+export interface RealmComponentsIdDeleteRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmComponentsIdGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmComponentsIdPutRequest {
+    realm: string;
+    id: string;
+    componentRepresentation: ComponentRepresentation;
+}
+
+export interface RealmComponentsIdSubComponentTypesGetRequest {
+    realm: string;
+    id: string;
+    type?: string;
+}
+
+export interface RealmComponentsPostRequest {
+    realm: string;
+    componentRepresentation: ComponentRepresentation;
+}
+
+/**
+ * 
+ */
+export class ComponentApi extends runtime.BaseAPI {
+
+    /**
+     */
+    async realmComponentsGetRaw(requestParameters: RealmComponentsGetRequest): 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 realmComponentsGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.name !== undefined) {
+            queryParameters['name'] = requestParameters.name;
+        }
+
+        if (requestParameters.parent !== undefined) {
+            queryParameters['parent'] = requestParameters.parent;
+        }
+
+        if (requestParameters.type !== undefined) {
+            queryParameters['type'] = requestParameters.type;
+        }
+
+        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}/components`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     */
+    async realmComponentsGet(requestParameters: RealmComponentsGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmComponentsGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     */
+    async realmComponentsIdDeleteRaw(requestParameters: RealmComponentsIdDeleteRequest): 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 realmComponentsIdDelete.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmComponentsIdDelete.');
+        }
+
+        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}/components/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async realmComponentsIdDelete(requestParameters: RealmComponentsIdDeleteRequest): Promise<void> {
+        await this.realmComponentsIdDeleteRaw(requestParameters);
+    }
+
+    /**
+     */
+    async realmComponentsIdGetRaw(requestParameters: RealmComponentsIdGetRequest): Promise<runtime.ApiResponse<ComponentRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmComponentsIdGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmComponentsIdGet.');
+        }
+
+        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}/components/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ComponentRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async realmComponentsIdGet(requestParameters: RealmComponentsIdGetRequest): Promise<ComponentRepresentation> {
+        const response = await this.realmComponentsIdGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     */
+    async realmComponentsIdPutRaw(requestParameters: RealmComponentsIdPutRequest): 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 realmComponentsIdPut.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmComponentsIdPut.');
+        }
+
+        if (requestParameters.componentRepresentation === null || requestParameters.componentRepresentation === undefined) {
+            throw new runtime.RequiredError('componentRepresentation','Required parameter requestParameters.componentRepresentation was null or undefined when calling realmComponentsIdPut.');
+        }
+
+        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}/components/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ComponentRepresentationToJSON(requestParameters.componentRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async realmComponentsIdPut(requestParameters: RealmComponentsIdPutRequest): Promise<void> {
+        await this.realmComponentsIdPutRaw(requestParameters);
+    }
+
+    /**
+     * List of subcomponent types that are available to configure for a particular parent component.
+     */
+    async realmComponentsIdSubComponentTypesGetRaw(requestParameters: RealmComponentsIdSubComponentTypesGetRequest): 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 realmComponentsIdSubComponentTypesGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmComponentsIdSubComponentTypesGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.type !== undefined) {
+            queryParameters['type'] = requestParameters.type;
+        }
+
+        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}/components/{id}/sub-component-types`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * List of subcomponent types that are available to configure for a particular parent component.
+     */
+    async realmComponentsIdSubComponentTypesGet(requestParameters: RealmComponentsIdSubComponentTypesGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmComponentsIdSubComponentTypesGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     */
+    async realmComponentsPostRaw(requestParameters: RealmComponentsPostRequest): 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 realmComponentsPost.');
+        }
+
+        if (requestParameters.componentRepresentation === null || requestParameters.componentRepresentation === undefined) {
+            throw new runtime.RequiredError('componentRepresentation','Required parameter requestParameters.componentRepresentation was null or undefined when calling realmComponentsPost.');
+        }
+
+        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}/components`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ComponentRepresentationToJSON(requestParameters.componentRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async realmComponentsPost(requestParameters: RealmComponentsPostRequest): Promise<void> {
+        await this.realmComponentsPostRaw(requestParameters);
+    }
+
+}

backend/keycloak/kc-client/apis/GroupsApi.ts

@@ -0,0 +1,555 @@
+/* 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 {
+    GroupRepresentation,
+    GroupRepresentationFromJSON,
+    GroupRepresentationToJSON,
+    ManagementPermissionReference,
+    ManagementPermissionReferenceFromJSON,
+    ManagementPermissionReferenceToJSON,
+} from '../models';
+
+export interface RealmGroupsCountGetRequest {
+    realm: string;
+    search?: string;
+    top?: boolean;
+}
+
+export interface RealmGroupsGetRequest {
+    realm: string;
+    briefRepresentation?: boolean;
+    first?: number;
+    max?: number;
+    search?: string;
+}
+
+export interface RealmGroupsIdChildrenPostRequest {
+    realm: string;
+    id: string;
+    groupRepresentation: GroupRepresentation;
+}
+
+export interface RealmGroupsIdDeleteRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmGroupsIdGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmGroupsIdManagementPermissionsGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmGroupsIdManagementPermissionsPutRequest {
+    realm: string;
+    id: string;
+    managementPermissionReference: ManagementPermissionReference;
+}
+
+export interface RealmGroupsIdMembersGetRequest {
+    realm: string;
+    id: string;
+    briefRepresentation?: boolean;
+    first?: number;
+    max?: number;
+}
+
+export interface RealmGroupsIdPutRequest {
+    realm: string;
+    id: string;
+    groupRepresentation: GroupRepresentation;
+}
+
+export interface RealmGroupsPostRequest {
+    realm: string;
+    groupRepresentation: GroupRepresentation;
+}
+
+/**
+ * 
+ */
+export class GroupsApi extends runtime.BaseAPI {
+
+    /**
+     * Returns the groups counts.
+     */
+    async realmGroupsCountGetRaw(requestParameters: RealmGroupsCountGetRequest): 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 realmGroupsCountGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.search !== undefined) {
+            queryParameters['search'] = requestParameters.search;
+        }
+
+        if (requestParameters.top !== undefined) {
+            queryParameters['top'] = requestParameters.top;
+        }
+
+        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}/groups/count`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Returns the groups counts.
+     */
+    async realmGroupsCountGet(requestParameters: RealmGroupsCountGetRequest): Promise<{ [key: string]: object; }> {
+        const response = await this.realmGroupsCountGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Get group hierarchy.
+     */
+    async realmGroupsGetRaw(requestParameters: RealmGroupsGetRequest): 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 realmGroupsGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.briefRepresentation !== undefined) {
+            queryParameters['briefRepresentation'] = requestParameters.briefRepresentation;
+        }
+
+        if (requestParameters.first !== undefined) {
+            queryParameters['first'] = requestParameters.first;
+        }
+
+        if (requestParameters.max !== undefined) {
+            queryParameters['max'] = requestParameters.max;
+        }
+
+        if (requestParameters.search !== undefined) {
+            queryParameters['search'] = requestParameters.search;
+        }
+
+        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}/groups`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get group hierarchy.
+     */
+    async realmGroupsGet(requestParameters: RealmGroupsGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmGroupsGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Set or create child.
+     */
+    async realmGroupsIdChildrenPostRaw(requestParameters: RealmGroupsIdChildrenPostRequest): 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 realmGroupsIdChildrenPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdChildrenPost.');
+        }
+
+        if (requestParameters.groupRepresentation === null || requestParameters.groupRepresentation === undefined) {
+            throw new runtime.RequiredError('groupRepresentation','Required parameter requestParameters.groupRepresentation was null or undefined when calling realmGroupsIdChildrenPost.');
+        }
+
+        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}/groups/{id}/children`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: GroupRepresentationToJSON(requestParameters.groupRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Set or create child.
+     */
+    async realmGroupsIdChildrenPost(requestParameters: RealmGroupsIdChildrenPostRequest): Promise<void> {
+        await this.realmGroupsIdChildrenPostRaw(requestParameters);
+    }
+
+    /**
+     */
+    async realmGroupsIdDeleteRaw(requestParameters: RealmGroupsIdDeleteRequest): 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 realmGroupsIdDelete.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdDelete.');
+        }
+
+        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}/groups/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async realmGroupsIdDelete(requestParameters: RealmGroupsIdDeleteRequest): Promise<void> {
+        await this.realmGroupsIdDeleteRaw(requestParameters);
+    }
+
+    /**
+     */
+    async realmGroupsIdGetRaw(requestParameters: RealmGroupsIdGetRequest): 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 realmGroupsIdGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdGet.');
+        }
+
+        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}/groups/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GroupRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async realmGroupsIdGet(requestParameters: RealmGroupsIdGetRequest): Promise<GroupRepresentation> {
+        const response = await this.realmGroupsIdGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Return object stating whether client Authorization permissions have been initialized or not and a reference
+     */
+    async realmGroupsIdManagementPermissionsGetRaw(requestParameters: RealmGroupsIdManagementPermissionsGetRequest): 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 realmGroupsIdManagementPermissionsGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdManagementPermissionsGet.');
+        }
+
+        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}/groups/{id}/management/permissions`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ManagementPermissionReferenceFromJSON(jsonValue));
+    }
+
+    /**
+     * Return object stating whether client Authorization permissions have been initialized or not and a reference
+     */
+    async realmGroupsIdManagementPermissionsGet(requestParameters: RealmGroupsIdManagementPermissionsGetRequest): Promise<ManagementPermissionReference> {
+        const response = await this.realmGroupsIdManagementPermissionsGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Return object stating whether client Authorization permissions have been initialized or not and a reference
+     */
+    async realmGroupsIdManagementPermissionsPutRaw(requestParameters: RealmGroupsIdManagementPermissionsPutRequest): 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 realmGroupsIdManagementPermissionsPut.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdManagementPermissionsPut.');
+        }
+
+        if (requestParameters.managementPermissionReference === null || requestParameters.managementPermissionReference === undefined) {
+            throw new runtime.RequiredError('managementPermissionReference','Required parameter requestParameters.managementPermissionReference was null or undefined when calling realmGroupsIdManagementPermissionsPut.');
+        }
+
+        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}/groups/{id}/management/permissions`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ManagementPermissionReferenceToJSON(requestParameters.managementPermissionReference),
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ManagementPermissionReferenceFromJSON(jsonValue));
+    }
+
+    /**
+     * Return object stating whether client Authorization permissions have been initialized or not and a reference
+     */
+    async realmGroupsIdManagementPermissionsPut(requestParameters: RealmGroupsIdManagementPermissionsPutRequest): Promise<ManagementPermissionReference> {
+        const response = await this.realmGroupsIdManagementPermissionsPutRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Get users   Returns a stream of users, filtered according to query parameters
+     */
+    async realmGroupsIdMembersGetRaw(requestParameters: RealmGroupsIdMembersGetRequest): 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 realmGroupsIdMembersGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdMembersGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.briefRepresentation !== undefined) {
+            queryParameters['briefRepresentation'] = requestParameters.briefRepresentation;
+        }
+
+        if (requestParameters.first !== undefined) {
+            queryParameters['first'] = requestParameters.first;
+        }
+
+        if (requestParameters.max !== undefined) {
+            queryParameters['max'] = requestParameters.max;
+        }
+
+        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}/groups/{id}/members`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get users   Returns a stream of users, filtered according to query parameters
+     */
+    async realmGroupsIdMembersGet(requestParameters: RealmGroupsIdMembersGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmGroupsIdMembersGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Update group, ignores subgroups.
+     */
+    async realmGroupsIdPutRaw(requestParameters: RealmGroupsIdPutRequest): 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 realmGroupsIdPut.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdPut.');
+        }
+
+        if (requestParameters.groupRepresentation === null || requestParameters.groupRepresentation === undefined) {
+            throw new runtime.RequiredError('groupRepresentation','Required parameter requestParameters.groupRepresentation was null or undefined when calling realmGroupsIdPut.');
+        }
+
+        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}/groups/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: GroupRepresentationToJSON(requestParameters.groupRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Update group, ignores subgroups.
+     */
+    async realmGroupsIdPut(requestParameters: RealmGroupsIdPutRequest): Promise<void> {
+        await this.realmGroupsIdPutRaw(requestParameters);
+    }
+
+    /**
+     * create or add a top level realm groupSet or create child.
+     */
+    async realmGroupsPostRaw(requestParameters: RealmGroupsPostRequest): 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 realmGroupsPost.');
+        }
+
+        if (requestParameters.groupRepresentation === null || requestParameters.groupRepresentation === undefined) {
+            throw new runtime.RequiredError('groupRepresentation','Required parameter requestParameters.groupRepresentation was null or undefined when calling realmGroupsPost.');
+        }
+
+        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}/groups`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: GroupRepresentationToJSON(requestParameters.groupRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * create or add a top level realm groupSet or create child.
+     */
+    async realmGroupsPost(requestParameters: RealmGroupsPostRequest): Promise<void> {
+        await this.realmGroupsPostRaw(requestParameters);
+    }
+
+}

backend/keycloak/kc-client/apis/IdentityProvidersApi.ts

@@ -0,0 +1,822 @@
+/* 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 {
+    IdentityProviderMapperRepresentation,
+    IdentityProviderMapperRepresentationFromJSON,
+    IdentityProviderMapperRepresentationToJSON,
+    IdentityProviderRepresentation,
+    IdentityProviderRepresentationFromJSON,
+    IdentityProviderRepresentationToJSON,
+    ManagementPermissionReference,
+    ManagementPermissionReferenceFromJSON,
+    ManagementPermissionReferenceToJSON,
+} from '../models';
+
+export interface RealmIdentityProviderImportConfigPostRequest {
+    realm: string;
+}
+
+export interface RealmIdentityProviderInstancesAliasDeleteRequest {
+    realm: string;
+    alias: string;
+}
+
+export interface RealmIdentityProviderInstancesAliasExportGetRequest {
+    realm: string;
+    alias: string;
+    format?: string;
+}
+
+export interface RealmIdentityProviderInstancesAliasGetRequest {
+    realm: string;
+    alias: string;
+}
+
+export interface RealmIdentityProviderInstancesAliasManagementPermissionsGetRequest {
+    realm: string;
+    alias: string;
+}
+
+export interface RealmIdentityProviderInstancesAliasManagementPermissionsPutRequest {
+    realm: string;
+    alias: string;
+    managementPermissionReference: ManagementPermissionReference;
+}
+
+export interface RealmIdentityProviderInstancesAliasMapperTypesGetRequest {
+    realm: string;
+    alias: string;
+}
+
+export interface RealmIdentityProviderInstancesAliasMappersGetRequest {
+    realm: string;
+    alias: string;
+}
+
+export interface RealmIdentityProviderInstancesAliasMappersIdDeleteRequest {
+    realm: string;
+    alias: string;
+    id: string;
+}
+
+export interface RealmIdentityProviderInstancesAliasMappersIdGetRequest {
+    realm: string;
+    alias: string;
+    id: string;
+}
+
+export interface RealmIdentityProviderInstancesAliasMappersIdPutRequest {
+    realm: string;
+    alias: string;
+    id: string;
+    identityProviderMapperRepresentation: IdentityProviderMapperRepresentation;
+}
+
+export interface RealmIdentityProviderInstancesAliasMappersPostRequest {
+    realm: string;
+    alias: string;
+    identityProviderMapperRepresentation: IdentityProviderMapperRepresentation;
+}
+
+export interface RealmIdentityProviderInstancesAliasPutRequest {
+    realm: string;
+    alias: string;
+    identityProviderRepresentation: IdentityProviderRepresentation;
+}
+
+export interface RealmIdentityProviderInstancesGetRequest {
+    realm: string;
+}
+
+export interface RealmIdentityProviderInstancesPostRequest {
+    realm: string;
+    identityProviderRepresentation: IdentityProviderRepresentation;
+}
+
+export interface RealmIdentityProviderProvidersProviderIdGetRequest {
+    realm: string;
+    providerId: string;
+}
+
+/**
+ * 
+ */
+export class IdentityProvidersApi extends runtime.BaseAPI {
+
+    /**
+     * Import identity provider from uploaded JSON file
+     */
+    async realmIdentityProviderImportConfigPostRaw(requestParameters: RealmIdentityProviderImportConfigPostRequest): 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 realmIdentityProviderImportConfigPost.');
+        }
+
+        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}/identity-provider/import-config`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Import identity provider from uploaded JSON file
+     */
+    async realmIdentityProviderImportConfigPost(requestParameters: RealmIdentityProviderImportConfigPostRequest): Promise<{ [key: string]: object; }> {
+        const response = await this.realmIdentityProviderImportConfigPostRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Delete the identity provider
+     */
+    async realmIdentityProviderInstancesAliasDeleteRaw(requestParameters: RealmIdentityProviderInstancesAliasDeleteRequest): 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 realmIdentityProviderInstancesAliasDelete.');
+        }
+
+        if (requestParameters.alias === null || requestParameters.alias === undefined) {
+            throw new runtime.RequiredError('alias','Required parameter requestParameters.alias was null or undefined when calling realmIdentityProviderInstancesAliasDelete.');
+        }
+
+        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}/identity-provider/instances/{alias}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"alias"}}`, encodeURIComponent(String(requestParameters.alias))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete the identity provider
+     */
+    async realmIdentityProviderInstancesAliasDelete(requestParameters: RealmIdentityProviderInstancesAliasDeleteRequest): Promise<void> {
+        await this.realmIdentityProviderInstancesAliasDeleteRaw(requestParameters);
+    }
+
+    /**
+     * Export public broker configuration for identity provider
+     */
+    async realmIdentityProviderInstancesAliasExportGetRaw(requestParameters: RealmIdentityProviderInstancesAliasExportGetRequest): 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 realmIdentityProviderInstancesAliasExportGet.');
+        }
+
+        if (requestParameters.alias === null || requestParameters.alias === undefined) {
+            throw new runtime.RequiredError('alias','Required parameter requestParameters.alias was null or undefined when calling realmIdentityProviderInstancesAliasExportGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.format !== undefined) {
+            queryParameters['format'] = requestParameters.format;
+        }
+
+        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}/identity-provider/instances/{alias}/export`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"alias"}}`, encodeURIComponent(String(requestParameters.alias))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Export public broker configuration for identity provider
+     */
+    async realmIdentityProviderInstancesAliasExportGet(requestParameters: RealmIdentityProviderInstancesAliasExportGetRequest): Promise<void> {
+        await this.realmIdentityProviderInstancesAliasExportGetRaw(requestParameters);
+    }
+
+    /**
+     * Get the identity provider
+     */
+    async realmIdentityProviderInstancesAliasGetRaw(requestParameters: RealmIdentityProviderInstancesAliasGetRequest): Promise<runtime.ApiResponse<IdentityProviderRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmIdentityProviderInstancesAliasGet.');
+        }
+
+        if (requestParameters.alias === null || requestParameters.alias === undefined) {
+            throw new runtime.RequiredError('alias','Required parameter requestParameters.alias was null or undefined when calling realmIdentityProviderInstancesAliasGet.');
+        }
+
+        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}/identity-provider/instances/{alias}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"alias"}}`, encodeURIComponent(String(requestParameters.alias))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => IdentityProviderRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Get the identity provider
+     */
+    async realmIdentityProviderInstancesAliasGet(requestParameters: RealmIdentityProviderInstancesAliasGetRequest): Promise<IdentityProviderRepresentation> {
+        const response = await this.realmIdentityProviderInstancesAliasGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Return object stating whether client Authorization permissions have been initialized or not and a reference
+     */
+    async realmIdentityProviderInstancesAliasManagementPermissionsGetRaw(requestParameters: RealmIdentityProviderInstancesAliasManagementPermissionsGetRequest): 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 realmIdentityProviderInstancesAliasManagementPermissionsGet.');
+        }
+
+        if (requestParameters.alias === null || requestParameters.alias === undefined) {
+            throw new runtime.RequiredError('alias','Required parameter requestParameters.alias was null or undefined when calling realmIdentityProviderInstancesAliasManagementPermissionsGet.');
+        }
+
+        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}/identity-provider/instances/{alias}/management/permissions`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"alias"}}`, encodeURIComponent(String(requestParameters.alias))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ManagementPermissionReferenceFromJSON(jsonValue));
+    }
+
+    /**
+     * Return object stating whether client Authorization permissions have been initialized or not and a reference
+     */
+    async realmIdentityProviderInstancesAliasManagementPermissionsGet(requestParameters: RealmIdentityProviderInstancesAliasManagementPermissionsGetRequest): Promise<ManagementPermissionReference> {
+        const response = await this.realmIdentityProviderInstancesAliasManagementPermissionsGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Return object stating whether client Authorization permissions have been initialized or not and a reference
+     */
+    async realmIdentityProviderInstancesAliasManagementPermissionsPutRaw(requestParameters: RealmIdentityProviderInstancesAliasManagementPermissionsPutRequest): 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 realmIdentityProviderInstancesAliasManagementPermissionsPut.');
+        }
+
+        if (requestParameters.alias === null || requestParameters.alias === undefined) {
+            throw new runtime.RequiredError('alias','Required parameter requestParameters.alias was null or undefined when calling realmIdentityProviderInstancesAliasManagementPermissionsPut.');
+        }
+
+        if (requestParameters.managementPermissionReference === null || requestParameters.managementPermissionReference === undefined) {
+            throw new runtime.RequiredError('managementPermissionReference','Required parameter requestParameters.managementPermissionReference was null or undefined when calling realmIdentityProviderInstancesAliasManagementPermissionsPut.');
+        }
+
+        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}/identity-provider/instances/{alias}/management/permissions`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"alias"}}`, encodeURIComponent(String(requestParameters.alias))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ManagementPermissionReferenceToJSON(requestParameters.managementPermissionReference),
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ManagementPermissionReferenceFromJSON(jsonValue));
+    }
+
+    /**
+     * Return object stating whether client Authorization permissions have been initialized or not and a reference
+     */
+    async realmIdentityProviderInstancesAliasManagementPermissionsPut(requestParameters: RealmIdentityProviderInstancesAliasManagementPermissionsPutRequest): Promise<ManagementPermissionReference> {
+        const response = await this.realmIdentityProviderInstancesAliasManagementPermissionsPutRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Get mapper types for identity provider
+     */
+    async realmIdentityProviderInstancesAliasMapperTypesGetRaw(requestParameters: RealmIdentityProviderInstancesAliasMapperTypesGetRequest): 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 realmIdentityProviderInstancesAliasMapperTypesGet.');
+        }
+
+        if (requestParameters.alias === null || requestParameters.alias === undefined) {
+            throw new runtime.RequiredError('alias','Required parameter requestParameters.alias was null or undefined when calling realmIdentityProviderInstancesAliasMapperTypesGet.');
+        }
+
+        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}/identity-provider/instances/{alias}/mapper-types`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"alias"}}`, encodeURIComponent(String(requestParameters.alias))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Get mapper types for identity provider
+     */
+    async realmIdentityProviderInstancesAliasMapperTypesGet(requestParameters: RealmIdentityProviderInstancesAliasMapperTypesGetRequest): Promise<void> {
+        await this.realmIdentityProviderInstancesAliasMapperTypesGetRaw(requestParameters);
+    }
+
+    /**
+     * Get mappers for identity provider
+     */
+    async realmIdentityProviderInstancesAliasMappersGetRaw(requestParameters: RealmIdentityProviderInstancesAliasMappersGetRequest): 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 realmIdentityProviderInstancesAliasMappersGet.');
+        }
+
+        if (requestParameters.alias === null || requestParameters.alias === undefined) {
+            throw new runtime.RequiredError('alias','Required parameter requestParameters.alias was null or undefined when calling realmIdentityProviderInstancesAliasMappersGet.');
+        }
+
+        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}/identity-provider/instances/{alias}/mappers`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"alias"}}`, encodeURIComponent(String(requestParameters.alias))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get mappers for identity provider
+     */
+    async realmIdentityProviderInstancesAliasMappersGet(requestParameters: RealmIdentityProviderInstancesAliasMappersGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmIdentityProviderInstancesAliasMappersGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Delete a mapper for the identity provider
+     */
+    async realmIdentityProviderInstancesAliasMappersIdDeleteRaw(requestParameters: RealmIdentityProviderInstancesAliasMappersIdDeleteRequest): 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 realmIdentityProviderInstancesAliasMappersIdDelete.');
+        }
+
+        if (requestParameters.alias === null || requestParameters.alias === undefined) {
+            throw new runtime.RequiredError('alias','Required parameter requestParameters.alias was null or undefined when calling realmIdentityProviderInstancesAliasMappersIdDelete.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmIdentityProviderInstancesAliasMappersIdDelete.');
+        }
+
+        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}/identity-provider/instances/{alias}/mappers/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"alias"}}`, encodeURIComponent(String(requestParameters.alias))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete a mapper for the identity provider
+     */
+    async realmIdentityProviderInstancesAliasMappersIdDelete(requestParameters: RealmIdentityProviderInstancesAliasMappersIdDeleteRequest): Promise<void> {
+        await this.realmIdentityProviderInstancesAliasMappersIdDeleteRaw(requestParameters);
+    }
+
+    /**
+     * Get mapper by id for the identity provider
+     */
+    async realmIdentityProviderInstancesAliasMappersIdGetRaw(requestParameters: RealmIdentityProviderInstancesAliasMappersIdGetRequest): Promise<runtime.ApiResponse<IdentityProviderMapperRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmIdentityProviderInstancesAliasMappersIdGet.');
+        }
+
+        if (requestParameters.alias === null || requestParameters.alias === undefined) {
+            throw new runtime.RequiredError('alias','Required parameter requestParameters.alias was null or undefined when calling realmIdentityProviderInstancesAliasMappersIdGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmIdentityProviderInstancesAliasMappersIdGet.');
+        }
+
+        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}/identity-provider/instances/{alias}/mappers/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"alias"}}`, encodeURIComponent(String(requestParameters.alias))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => IdentityProviderMapperRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Get mapper by id for the identity provider
+     */
+    async realmIdentityProviderInstancesAliasMappersIdGet(requestParameters: RealmIdentityProviderInstancesAliasMappersIdGetRequest): Promise<IdentityProviderMapperRepresentation> {
+        const response = await this.realmIdentityProviderInstancesAliasMappersIdGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Update a mapper for the identity provider
+     */
+    async realmIdentityProviderInstancesAliasMappersIdPutRaw(requestParameters: RealmIdentityProviderInstancesAliasMappersIdPutRequest): 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 realmIdentityProviderInstancesAliasMappersIdPut.');
+        }
+
+        if (requestParameters.alias === null || requestParameters.alias === undefined) {
+            throw new runtime.RequiredError('alias','Required parameter requestParameters.alias was null or undefined when calling realmIdentityProviderInstancesAliasMappersIdPut.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmIdentityProviderInstancesAliasMappersIdPut.');
+        }
+
+        if (requestParameters.identityProviderMapperRepresentation === null || requestParameters.identityProviderMapperRepresentation === undefined) {
+            throw new runtime.RequiredError('identityProviderMapperRepresentation','Required parameter requestParameters.identityProviderMapperRepresentation was null or undefined when calling realmIdentityProviderInstancesAliasMappersIdPut.');
+        }
+
+        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}/identity-provider/instances/{alias}/mappers/{id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"alias"}}`, encodeURIComponent(String(requestParameters.alias))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: IdentityProviderMapperRepresentationToJSON(requestParameters.identityProviderMapperRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Update a mapper for the identity provider
+     */
+    async realmIdentityProviderInstancesAliasMappersIdPut(requestParameters: RealmIdentityProviderInstancesAliasMappersIdPutRequest): Promise<void> {
+        await this.realmIdentityProviderInstancesAliasMappersIdPutRaw(requestParameters);
+    }
+
+    /**
+     * Add a mapper to identity provider
+     */
+    async realmIdentityProviderInstancesAliasMappersPostRaw(requestParameters: RealmIdentityProviderInstancesAliasMappersPostRequest): 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 realmIdentityProviderInstancesAliasMappersPost.');
+        }
+
+        if (requestParameters.alias === null || requestParameters.alias === undefined) {
+            throw new runtime.RequiredError('alias','Required parameter requestParameters.alias was null or undefined when calling realmIdentityProviderInstancesAliasMappersPost.');
+        }
+
+        if (requestParameters.identityProviderMapperRepresentation === null || requestParameters.identityProviderMapperRepresentation === undefined) {
+            throw new runtime.RequiredError('identityProviderMapperRepresentation','Required parameter requestParameters.identityProviderMapperRepresentation was null or undefined when calling realmIdentityProviderInstancesAliasMappersPost.');
+        }
+
+        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}/identity-provider/instances/{alias}/mappers`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"alias"}}`, encodeURIComponent(String(requestParameters.alias))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: IdentityProviderMapperRepresentationToJSON(requestParameters.identityProviderMapperRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Add a mapper to identity provider
+     */
+    async realmIdentityProviderInstancesAliasMappersPost(requestParameters: RealmIdentityProviderInstancesAliasMappersPostRequest): Promise<void> {
+        await this.realmIdentityProviderInstancesAliasMappersPostRaw(requestParameters);
+    }
+
+    /**
+     * Update the identity provider
+     */
+    async realmIdentityProviderInstancesAliasPutRaw(requestParameters: RealmIdentityProviderInstancesAliasPutRequest): 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 realmIdentityProviderInstancesAliasPut.');
+        }
+
+        if (requestParameters.alias === null || requestParameters.alias === undefined) {
+            throw new runtime.RequiredError('alias','Required parameter requestParameters.alias was null or undefined when calling realmIdentityProviderInstancesAliasPut.');
+        }
+
+        if (requestParameters.identityProviderRepresentation === null || requestParameters.identityProviderRepresentation === undefined) {
+            throw new runtime.RequiredError('identityProviderRepresentation','Required parameter requestParameters.identityProviderRepresentation was null or undefined when calling realmIdentityProviderInstancesAliasPut.');
+        }
+
+        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}/identity-provider/instances/{alias}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"alias"}}`, encodeURIComponent(String(requestParameters.alias))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: IdentityProviderRepresentationToJSON(requestParameters.identityProviderRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Update the identity provider
+     */
+    async realmIdentityProviderInstancesAliasPut(requestParameters: RealmIdentityProviderInstancesAliasPutRequest): Promise<void> {
+        await this.realmIdentityProviderInstancesAliasPutRaw(requestParameters);
+    }
+
+    /**
+     * Get identity providers
+     */
+    async realmIdentityProviderInstancesGetRaw(requestParameters: RealmIdentityProviderInstancesGetRequest): 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 realmIdentityProviderInstancesGet.');
+        }
+
+        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}/identity-provider/instances`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get identity providers
+     */
+    async realmIdentityProviderInstancesGet(requestParameters: RealmIdentityProviderInstancesGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmIdentityProviderInstancesGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Create a new identity provider
+     */
+    async realmIdentityProviderInstancesPostRaw(requestParameters: RealmIdentityProviderInstancesPostRequest): 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 realmIdentityProviderInstancesPost.');
+        }
+
+        if (requestParameters.identityProviderRepresentation === null || requestParameters.identityProviderRepresentation === undefined) {
+            throw new runtime.RequiredError('identityProviderRepresentation','Required parameter requestParameters.identityProviderRepresentation was null or undefined when calling realmIdentityProviderInstancesPost.');
+        }
+
+        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}/identity-provider/instances`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: IdentityProviderRepresentationToJSON(requestParameters.identityProviderRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Create a new identity provider
+     */
+    async realmIdentityProviderInstancesPost(requestParameters: RealmIdentityProviderInstancesPostRequest): Promise<void> {
+        await this.realmIdentityProviderInstancesPostRaw(requestParameters);
+    }
+
+    /**
+     * Get identity providers
+     */
+    async realmIdentityProviderProvidersProviderIdGetRaw(requestParameters: RealmIdentityProviderProvidersProviderIdGetRequest): 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 realmIdentityProviderProvidersProviderIdGet.');
+        }
+
+        if (requestParameters.providerId === null || requestParameters.providerId === undefined) {
+            throw new runtime.RequiredError('providerId','Required parameter requestParameters.providerId was null or undefined when calling realmIdentityProviderProvidersProviderIdGet.');
+        }
+
+        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}/identity-provider/providers/{provider_id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"provider_id"}}`, encodeURIComponent(String(requestParameters.providerId))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Get identity providers
+     */
+    async realmIdentityProviderProvidersProviderIdGet(requestParameters: RealmIdentityProviderProvidersProviderIdGetRequest): Promise<void> {
+        await this.realmIdentityProviderProvidersProviderIdGetRaw(requestParameters);
+    }
+
+}

backend/keycloak/kc-client/apis/KeyApi.ts

@@ -0,0 +1,68 @@
+/* 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 {
+    KeysMetadataRepresentation,
+    KeysMetadataRepresentationFromJSON,
+    KeysMetadataRepresentationToJSON,
+} from '../models';
+
+export interface RealmKeysGetRequest {
+    realm: string;
+}
+
+/**
+ * 
+ */
+export class KeyApi extends runtime.BaseAPI {
+
+    /**
+     */
+    async realmKeysGetRaw(requestParameters: RealmKeysGetRequest): Promise<runtime.ApiResponse<KeysMetadataRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmKeysGet.');
+        }
+
+        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}/keys`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => KeysMetadataRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async realmKeysGet(requestParameters: RealmKeysGetRequest): Promise<KeysMetadataRepresentation> {
+        const response = await this.realmKeysGetRaw(requestParameters);
+        return await response.value();
+    }
+
+}

backend/keycloak/kc-client/apis/ProtocolMappersApi.ts

@@ -0,0 +1,766 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Keycloak Admin REST API
+ * This is a REST API reference for the Keycloak Admin
+ *
+ * The version of the OpenAPI document: 1
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import * as runtime from '../runtime';
+import {
+    ProtocolMapperRepresentation,
+    ProtocolMapperRepresentationFromJSON,
+    ProtocolMapperRepresentationToJSON,
+} from '../models';
+
+export interface RealmClientScopesId1ProtocolMappersModelsId2DeleteRequest {
+    realm: string;
+    id1: string;
+    id2: string;
+}
+
+export interface RealmClientScopesId1ProtocolMappersModelsId2GetRequest {
+    realm: string;
+    id1: string;
+    id2: string;
+}
+
+export interface RealmClientScopesId1ProtocolMappersModelsId2PutRequest {
+    realm: string;
+    id1: string;
+    id2: string;
+    protocolMapperRepresentation: ProtocolMapperRepresentation;
+}
+
+export interface RealmClientScopesIdProtocolMappersAddModelsPostRequest {
+    realm: string;
+    id: string;
+    protocolMapperRepresentation: Array<ProtocolMapperRepresentation>;
+}
+
+export interface RealmClientScopesIdProtocolMappersModelsGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmClientScopesIdProtocolMappersModelsPostRequest {
+    realm: string;
+    id: string;
+    protocolMapperRepresentation: ProtocolMapperRepresentation;
+}
+
+export interface RealmClientScopesIdProtocolMappersProtocolProtocolGetRequest {
+    realm: string;
+    id: string;
+    protocol: string;
+}
+
+export interface RealmClientsId1ProtocolMappersModelsId2DeleteRequest {
+    realm: string;
+    id1: string;
+    id2: string;
+}
+
+export interface RealmClientsId1ProtocolMappersModelsId2GetRequest {
+    realm: string;
+    id1: string;
+    id2: string;
+}
+
+export interface RealmClientsId1ProtocolMappersModelsId2PutRequest {
+    realm: string;
+    id1: string;
+    id2: string;
+    protocolMapperRepresentation: ProtocolMapperRepresentation;
+}
+
+export interface RealmClientsIdProtocolMappersAddModelsPostRequest {
+    realm: string;
+    id: string;
+    protocolMapperRepresentation: Array<ProtocolMapperRepresentation>;
+}
+
+export interface RealmClientsIdProtocolMappersModelsGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmClientsIdProtocolMappersModelsPostRequest {
+    realm: string;
+    id: string;
+    protocolMapperRepresentation: ProtocolMapperRepresentation;
+}
+
+export interface RealmClientsIdProtocolMappersProtocolProtocolGetRequest {
+    realm: string;
+    id: string;
+    protocol: string;
+}
+
+/**
+ * 
+ */
+export class ProtocolMappersApi extends runtime.BaseAPI {
+
+    /**
+     * Delete the mapper
+     */
+    async realmClientScopesId1ProtocolMappersModelsId2DeleteRaw(requestParameters: RealmClientScopesId1ProtocolMappersModelsId2DeleteRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Delete.');
+        }
+
+        if (requestParameters.id1 === null || requestParameters.id1 === undefined) {
+            throw new runtime.RequiredError('id1','Required parameter requestParameters.id1 was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Delete.');
+        }
+
+        if (requestParameters.id2 === null || requestParameters.id2 === undefined) {
+            throw new runtime.RequiredError('id2','Required parameter requestParameters.id2 was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Delete.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/client-scopes/{id1}/protocol-mappers/models/{id2}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id1"}}`, encodeURIComponent(String(requestParameters.id1))).replace(`{${"id2"}}`, encodeURIComponent(String(requestParameters.id2))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete the mapper
+     */
+    async realmClientScopesId1ProtocolMappersModelsId2Delete(requestParameters: RealmClientScopesId1ProtocolMappersModelsId2DeleteRequest): Promise<void> {
+        await this.realmClientScopesId1ProtocolMappersModelsId2DeleteRaw(requestParameters);
+    }
+
+    /**
+     * Get mapper by id
+     */
+    async realmClientScopesId1ProtocolMappersModelsId2GetRaw(requestParameters: RealmClientScopesId1ProtocolMappersModelsId2GetRequest): Promise<runtime.ApiResponse<ProtocolMapperRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Get.');
+        }
+
+        if (requestParameters.id1 === null || requestParameters.id1 === undefined) {
+            throw new runtime.RequiredError('id1','Required parameter requestParameters.id1 was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Get.');
+        }
+
+        if (requestParameters.id2 === null || requestParameters.id2 === undefined) {
+            throw new runtime.RequiredError('id2','Required parameter requestParameters.id2 was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Get.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/client-scopes/{id1}/protocol-mappers/models/{id2}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id1"}}`, encodeURIComponent(String(requestParameters.id1))).replace(`{${"id2"}}`, encodeURIComponent(String(requestParameters.id2))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProtocolMapperRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Get mapper by id
+     */
+    async realmClientScopesId1ProtocolMappersModelsId2Get(requestParameters: RealmClientScopesId1ProtocolMappersModelsId2GetRequest): Promise<ProtocolMapperRepresentation> {
+        const response = await this.realmClientScopesId1ProtocolMappersModelsId2GetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Update the mapper
+     */
+    async realmClientScopesId1ProtocolMappersModelsId2PutRaw(requestParameters: RealmClientScopesId1ProtocolMappersModelsId2PutRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Put.');
+        }
+
+        if (requestParameters.id1 === null || requestParameters.id1 === undefined) {
+            throw new runtime.RequiredError('id1','Required parameter requestParameters.id1 was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Put.');
+        }
+
+        if (requestParameters.id2 === null || requestParameters.id2 === undefined) {
+            throw new runtime.RequiredError('id2','Required parameter requestParameters.id2 was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Put.');
+        }
+
+        if (requestParameters.protocolMapperRepresentation === null || requestParameters.protocolMapperRepresentation === undefined) {
+            throw new runtime.RequiredError('protocolMapperRepresentation','Required parameter requestParameters.protocolMapperRepresentation was null or undefined when calling realmClientScopesId1ProtocolMappersModelsId2Put.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/client-scopes/{id1}/protocol-mappers/models/{id2}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id1"}}`, encodeURIComponent(String(requestParameters.id1))).replace(`{${"id2"}}`, encodeURIComponent(String(requestParameters.id2))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ProtocolMapperRepresentationToJSON(requestParameters.protocolMapperRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Update the mapper
+     */
+    async realmClientScopesId1ProtocolMappersModelsId2Put(requestParameters: RealmClientScopesId1ProtocolMappersModelsId2PutRequest): Promise<void> {
+        await this.realmClientScopesId1ProtocolMappersModelsId2PutRaw(requestParameters);
+    }
+
+    /**
+     * Create multiple mappers
+     */
+    async realmClientScopesIdProtocolMappersAddModelsPostRaw(requestParameters: RealmClientScopesIdProtocolMappersAddModelsPostRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesIdProtocolMappersAddModelsPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientScopesIdProtocolMappersAddModelsPost.');
+        }
+
+        if (requestParameters.protocolMapperRepresentation === null || requestParameters.protocolMapperRepresentation === undefined) {
+            throw new runtime.RequiredError('protocolMapperRepresentation','Required parameter requestParameters.protocolMapperRepresentation was null or undefined when calling realmClientScopesIdProtocolMappersAddModelsPost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/client-scopes/{id}/protocol-mappers/add-models`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.protocolMapperRepresentation.map(ProtocolMapperRepresentationToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Create multiple mappers
+     */
+    async realmClientScopesIdProtocolMappersAddModelsPost(requestParameters: RealmClientScopesIdProtocolMappersAddModelsPostRequest): Promise<void> {
+        await this.realmClientScopesIdProtocolMappersAddModelsPostRaw(requestParameters);
+    }
+
+    /**
+     * Get mappers
+     */
+    async realmClientScopesIdProtocolMappersModelsGetRaw(requestParameters: RealmClientScopesIdProtocolMappersModelsGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesIdProtocolMappersModelsGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientScopesIdProtocolMappersModelsGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/client-scopes/{id}/protocol-mappers/models`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get mappers
+     */
+    async realmClientScopesIdProtocolMappersModelsGet(requestParameters: RealmClientScopesIdProtocolMappersModelsGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmClientScopesIdProtocolMappersModelsGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Create a mapper
+     */
+    async realmClientScopesIdProtocolMappersModelsPostRaw(requestParameters: RealmClientScopesIdProtocolMappersModelsPostRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesIdProtocolMappersModelsPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientScopesIdProtocolMappersModelsPost.');
+        }
+
+        if (requestParameters.protocolMapperRepresentation === null || requestParameters.protocolMapperRepresentation === undefined) {
+            throw new runtime.RequiredError('protocolMapperRepresentation','Required parameter requestParameters.protocolMapperRepresentation was null or undefined when calling realmClientScopesIdProtocolMappersModelsPost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/client-scopes/{id}/protocol-mappers/models`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ProtocolMapperRepresentationToJSON(requestParameters.protocolMapperRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Create a mapper
+     */
+    async realmClientScopesIdProtocolMappersModelsPost(requestParameters: RealmClientScopesIdProtocolMappersModelsPostRequest): Promise<void> {
+        await this.realmClientScopesIdProtocolMappersModelsPostRaw(requestParameters);
+    }
+
+    /**
+     * Get mappers by name for a specific protocol
+     */
+    async realmClientScopesIdProtocolMappersProtocolProtocolGetRaw(requestParameters: RealmClientScopesIdProtocolMappersProtocolProtocolGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientScopesIdProtocolMappersProtocolProtocolGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientScopesIdProtocolMappersProtocolProtocolGet.');
+        }
+
+        if (requestParameters.protocol === null || requestParameters.protocol === undefined) {
+            throw new runtime.RequiredError('protocol','Required parameter requestParameters.protocol was null or undefined when calling realmClientScopesIdProtocolMappersProtocolProtocolGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/client-scopes/{id}/protocol-mappers/protocol/{protocol}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"protocol"}}`, encodeURIComponent(String(requestParameters.protocol))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get mappers by name for a specific protocol
+     */
+    async realmClientScopesIdProtocolMappersProtocolProtocolGet(requestParameters: RealmClientScopesIdProtocolMappersProtocolProtocolGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmClientScopesIdProtocolMappersProtocolProtocolGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Delete the mapper
+     */
+    async realmClientsId1ProtocolMappersModelsId2DeleteRaw(requestParameters: RealmClientsId1ProtocolMappersModelsId2DeleteRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Delete.');
+        }
+
+        if (requestParameters.id1 === null || requestParameters.id1 === undefined) {
+            throw new runtime.RequiredError('id1','Required parameter requestParameters.id1 was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Delete.');
+        }
+
+        if (requestParameters.id2 === null || requestParameters.id2 === undefined) {
+            throw new runtime.RequiredError('id2','Required parameter requestParameters.id2 was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Delete.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id1}/protocol-mappers/models/{id2}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id1"}}`, encodeURIComponent(String(requestParameters.id1))).replace(`{${"id2"}}`, encodeURIComponent(String(requestParameters.id2))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete the mapper
+     */
+    async realmClientsId1ProtocolMappersModelsId2Delete(requestParameters: RealmClientsId1ProtocolMappersModelsId2DeleteRequest): Promise<void> {
+        await this.realmClientsId1ProtocolMappersModelsId2DeleteRaw(requestParameters);
+    }
+
+    /**
+     * Get mapper by id
+     */
+    async realmClientsId1ProtocolMappersModelsId2GetRaw(requestParameters: RealmClientsId1ProtocolMappersModelsId2GetRequest): Promise<runtime.ApiResponse<ProtocolMapperRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Get.');
+        }
+
+        if (requestParameters.id1 === null || requestParameters.id1 === undefined) {
+            throw new runtime.RequiredError('id1','Required parameter requestParameters.id1 was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Get.');
+        }
+
+        if (requestParameters.id2 === null || requestParameters.id2 === undefined) {
+            throw new runtime.RequiredError('id2','Required parameter requestParameters.id2 was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Get.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id1}/protocol-mappers/models/{id2}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id1"}}`, encodeURIComponent(String(requestParameters.id1))).replace(`{${"id2"}}`, encodeURIComponent(String(requestParameters.id2))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProtocolMapperRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Get mapper by id
+     */
+    async realmClientsId1ProtocolMappersModelsId2Get(requestParameters: RealmClientsId1ProtocolMappersModelsId2GetRequest): Promise<ProtocolMapperRepresentation> {
+        const response = await this.realmClientsId1ProtocolMappersModelsId2GetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Update the mapper
+     */
+    async realmClientsId1ProtocolMappersModelsId2PutRaw(requestParameters: RealmClientsId1ProtocolMappersModelsId2PutRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Put.');
+        }
+
+        if (requestParameters.id1 === null || requestParameters.id1 === undefined) {
+            throw new runtime.RequiredError('id1','Required parameter requestParameters.id1 was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Put.');
+        }
+
+        if (requestParameters.id2 === null || requestParameters.id2 === undefined) {
+            throw new runtime.RequiredError('id2','Required parameter requestParameters.id2 was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Put.');
+        }
+
+        if (requestParameters.protocolMapperRepresentation === null || requestParameters.protocolMapperRepresentation === undefined) {
+            throw new runtime.RequiredError('protocolMapperRepresentation','Required parameter requestParameters.protocolMapperRepresentation was null or undefined when calling realmClientsId1ProtocolMappersModelsId2Put.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id1}/protocol-mappers/models/{id2}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id1"}}`, encodeURIComponent(String(requestParameters.id1))).replace(`{${"id2"}}`, encodeURIComponent(String(requestParameters.id2))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ProtocolMapperRepresentationToJSON(requestParameters.protocolMapperRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Update the mapper
+     */
+    async realmClientsId1ProtocolMappersModelsId2Put(requestParameters: RealmClientsId1ProtocolMappersModelsId2PutRequest): Promise<void> {
+        await this.realmClientsId1ProtocolMappersModelsId2PutRaw(requestParameters);
+    }
+
+    /**
+     * Create multiple mappers
+     */
+    async realmClientsIdProtocolMappersAddModelsPostRaw(requestParameters: RealmClientsIdProtocolMappersAddModelsPostRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsIdProtocolMappersAddModelsPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdProtocolMappersAddModelsPost.');
+        }
+
+        if (requestParameters.protocolMapperRepresentation === null || requestParameters.protocolMapperRepresentation === undefined) {
+            throw new runtime.RequiredError('protocolMapperRepresentation','Required parameter requestParameters.protocolMapperRepresentation was null or undefined when calling realmClientsIdProtocolMappersAddModelsPost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id}/protocol-mappers/add-models`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.protocolMapperRepresentation.map(ProtocolMapperRepresentationToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Create multiple mappers
+     */
+    async realmClientsIdProtocolMappersAddModelsPost(requestParameters: RealmClientsIdProtocolMappersAddModelsPostRequest): Promise<void> {
+        await this.realmClientsIdProtocolMappersAddModelsPostRaw(requestParameters);
+    }
+
+    /**
+     * Get mappers
+     */
+    async realmClientsIdProtocolMappersModelsGetRaw(requestParameters: RealmClientsIdProtocolMappersModelsGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsIdProtocolMappersModelsGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdProtocolMappersModelsGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id}/protocol-mappers/models`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get mappers
+     */
+    async realmClientsIdProtocolMappersModelsGet(requestParameters: RealmClientsIdProtocolMappersModelsGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmClientsIdProtocolMappersModelsGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Create a mapper
+     */
+    async realmClientsIdProtocolMappersModelsPostRaw(requestParameters: RealmClientsIdProtocolMappersModelsPostRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsIdProtocolMappersModelsPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdProtocolMappersModelsPost.');
+        }
+
+        if (requestParameters.protocolMapperRepresentation === null || requestParameters.protocolMapperRepresentation === undefined) {
+            throw new runtime.RequiredError('protocolMapperRepresentation','Required parameter requestParameters.protocolMapperRepresentation was null or undefined when calling realmClientsIdProtocolMappersModelsPost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id}/protocol-mappers/models`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ProtocolMapperRepresentationToJSON(requestParameters.protocolMapperRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Create a mapper
+     */
+    async realmClientsIdProtocolMappersModelsPost(requestParameters: RealmClientsIdProtocolMappersModelsPostRequest): Promise<void> {
+        await this.realmClientsIdProtocolMappersModelsPostRaw(requestParameters);
+    }
+
+    /**
+     * Get mappers by name for a specific protocol
+     */
+    async realmClientsIdProtocolMappersProtocolProtocolGetRaw(requestParameters: RealmClientsIdProtocolMappersProtocolProtocolGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientsIdProtocolMappersProtocolProtocolGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmClientsIdProtocolMappersProtocolProtocolGet.');
+        }
+
+        if (requestParameters.protocol === null || requestParameters.protocol === undefined) {
+            throw new runtime.RequiredError('protocol','Required parameter requestParameters.protocol was null or undefined when calling realmClientsIdProtocolMappersProtocolProtocolGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("access_token", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/{realm}/clients/{id}/protocol-mappers/protocol/{protocol}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"protocol"}}`, encodeURIComponent(String(requestParameters.protocol))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get mappers by name for a specific protocol
+     */
+    async realmClientsIdProtocolMappersProtocolProtocolGet(requestParameters: RealmClientsIdProtocolMappersProtocolProtocolGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmClientsIdProtocolMappersProtocolProtocolGetRaw(requestParameters);
+        return await response.value();
+    }
+
+}

backend/keycloak/kc-client/apis/RoleMapperApi.ts

@@ -0,0 +1,633 @@
+/* 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 {
+    MappingsRepresentation,
+    MappingsRepresentationFromJSON,
+    MappingsRepresentationToJSON,
+    RoleRepresentation,
+    RoleRepresentationFromJSON,
+    RoleRepresentationToJSON,
+} from '../models';
+
+export interface RealmGroupsIdRoleMappingsGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmGroupsIdRoleMappingsRealmAvailableGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmGroupsIdRoleMappingsRealmCompositeGetRequest {
+    realm: string;
+    id: string;
+    briefRepresentation?: boolean;
+}
+
+export interface RealmGroupsIdRoleMappingsRealmDeleteRequest {
+    realm: string;
+    id: string;
+    roleRepresentation: Array<RoleRepresentation>;
+}
+
+export interface RealmGroupsIdRoleMappingsRealmGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmGroupsIdRoleMappingsRealmPostRequest {
+    realm: string;
+    id: string;
+    roleRepresentation: Array<RoleRepresentation>;
+}
+
+export interface RealmUsersIdRoleMappingsGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmUsersIdRoleMappingsRealmAvailableGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmUsersIdRoleMappingsRealmCompositeGetRequest {
+    realm: string;
+    id: string;
+    briefRepresentation?: boolean;
+}
+
+export interface RealmUsersIdRoleMappingsRealmDeleteRequest {
+    realm: string;
+    id: string;
+    roleRepresentation: Array<RoleRepresentation>;
+}
+
+export interface RealmUsersIdRoleMappingsRealmGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmUsersIdRoleMappingsRealmPostRequest {
+    realm: string;
+    id: string;
+    roleRepresentation: Array<RoleRepresentation>;
+}
+
+/**
+ * 
+ */
+export class RoleMapperApi extends runtime.BaseAPI {
+
+    /**
+     * Get role mappings
+     */
+    async realmGroupsIdRoleMappingsGetRaw(requestParameters: RealmGroupsIdRoleMappingsGetRequest): Promise<runtime.ApiResponse<MappingsRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmGroupsIdRoleMappingsGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdRoleMappingsGet.');
+        }
+
+        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}/groups/{id}/role-mappings`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => MappingsRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Get role mappings
+     */
+    async realmGroupsIdRoleMappingsGet(requestParameters: RealmGroupsIdRoleMappingsGetRequest): Promise<MappingsRepresentation> {
+        const response = await this.realmGroupsIdRoleMappingsGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Get realm-level roles that can be mapped
+     */
+    async realmGroupsIdRoleMappingsRealmAvailableGetRaw(requestParameters: RealmGroupsIdRoleMappingsRealmAvailableGetRequest): 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 realmGroupsIdRoleMappingsRealmAvailableGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdRoleMappingsRealmAvailableGet.');
+        }
+
+        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}/groups/{id}/role-mappings/realm/available`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get realm-level roles that can be mapped
+     */
+    async realmGroupsIdRoleMappingsRealmAvailableGet(requestParameters: RealmGroupsIdRoleMappingsRealmAvailableGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmGroupsIdRoleMappingsRealmAvailableGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Get effective realm-level role mappings   This will recurse all composite roles to get the result.
+     */
+    async realmGroupsIdRoleMappingsRealmCompositeGetRaw(requestParameters: RealmGroupsIdRoleMappingsRealmCompositeGetRequest): 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 realmGroupsIdRoleMappingsRealmCompositeGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdRoleMappingsRealmCompositeGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.briefRepresentation !== undefined) {
+            queryParameters['briefRepresentation'] = requestParameters.briefRepresentation;
+        }
+
+        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}/groups/{id}/role-mappings/realm/composite`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get effective realm-level role mappings   This will recurse all composite roles to get the result.
+     */
+    async realmGroupsIdRoleMappingsRealmCompositeGet(requestParameters: RealmGroupsIdRoleMappingsRealmCompositeGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmGroupsIdRoleMappingsRealmCompositeGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Delete realm-level role mappings
+     */
+    async realmGroupsIdRoleMappingsRealmDeleteRaw(requestParameters: RealmGroupsIdRoleMappingsRealmDeleteRequest): 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 realmGroupsIdRoleMappingsRealmDelete.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdRoleMappingsRealmDelete.');
+        }
+
+        if (requestParameters.roleRepresentation === null || requestParameters.roleRepresentation === undefined) {
+            throw new runtime.RequiredError('roleRepresentation','Required parameter requestParameters.roleRepresentation was null or undefined when calling realmGroupsIdRoleMappingsRealmDelete.');
+        }
+
+        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}/groups/{id}/role-mappings/realm`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.roleRepresentation.map(RoleRepresentationToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete realm-level role mappings
+     */
+    async realmGroupsIdRoleMappingsRealmDelete(requestParameters: RealmGroupsIdRoleMappingsRealmDeleteRequest): Promise<void> {
+        await this.realmGroupsIdRoleMappingsRealmDeleteRaw(requestParameters);
+    }
+
+    /**
+     * Get realm-level role mappings
+     */
+    async realmGroupsIdRoleMappingsRealmGetRaw(requestParameters: RealmGroupsIdRoleMappingsRealmGetRequest): 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 realmGroupsIdRoleMappingsRealmGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdRoleMappingsRealmGet.');
+        }
+
+        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}/groups/{id}/role-mappings/realm`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get realm-level role mappings
+     */
+    async realmGroupsIdRoleMappingsRealmGet(requestParameters: RealmGroupsIdRoleMappingsRealmGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmGroupsIdRoleMappingsRealmGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Add realm-level role mappings to the user
+     */
+    async realmGroupsIdRoleMappingsRealmPostRaw(requestParameters: RealmGroupsIdRoleMappingsRealmPostRequest): 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 realmGroupsIdRoleMappingsRealmPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmGroupsIdRoleMappingsRealmPost.');
+        }
+
+        if (requestParameters.roleRepresentation === null || requestParameters.roleRepresentation === undefined) {
+            throw new runtime.RequiredError('roleRepresentation','Required parameter requestParameters.roleRepresentation was null or undefined when calling realmGroupsIdRoleMappingsRealmPost.');
+        }
+
+        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}/groups/{id}/role-mappings/realm`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.roleRepresentation.map(RoleRepresentationToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Add realm-level role mappings to the user
+     */
+    async realmGroupsIdRoleMappingsRealmPost(requestParameters: RealmGroupsIdRoleMappingsRealmPostRequest): Promise<void> {
+        await this.realmGroupsIdRoleMappingsRealmPostRaw(requestParameters);
+    }
+
+    /**
+     * Get role mappings
+     */
+    async realmUsersIdRoleMappingsGetRaw(requestParameters: RealmUsersIdRoleMappingsGetRequest): Promise<runtime.ApiResponse<MappingsRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmUsersIdRoleMappingsGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUsersIdRoleMappingsGet.');
+        }
+
+        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/{id}/role-mappings`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => MappingsRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Get role mappings
+     */
+    async realmUsersIdRoleMappingsGet(requestParameters: RealmUsersIdRoleMappingsGetRequest): Promise<MappingsRepresentation> {
+        const response = await this.realmUsersIdRoleMappingsGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Get realm-level roles that can be mapped
+     */
+    async realmUsersIdRoleMappingsRealmAvailableGetRaw(requestParameters: RealmUsersIdRoleMappingsRealmAvailableGetRequest): 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 realmUsersIdRoleMappingsRealmAvailableGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUsersIdRoleMappingsRealmAvailableGet.');
+        }
+
+        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/{id}/role-mappings/realm/available`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get realm-level roles that can be mapped
+     */
+    async realmUsersIdRoleMappingsRealmAvailableGet(requestParameters: RealmUsersIdRoleMappingsRealmAvailableGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmUsersIdRoleMappingsRealmAvailableGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Get effective realm-level role mappings   This will recurse all composite roles to get the result.
+     */
+    async realmUsersIdRoleMappingsRealmCompositeGetRaw(requestParameters: RealmUsersIdRoleMappingsRealmCompositeGetRequest): 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 realmUsersIdRoleMappingsRealmCompositeGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUsersIdRoleMappingsRealmCompositeGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.briefRepresentation !== undefined) {
+            queryParameters['briefRepresentation'] = requestParameters.briefRepresentation;
+        }
+
+        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/{id}/role-mappings/realm/composite`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get effective realm-level role mappings   This will recurse all composite roles to get the result.
+     */
+    async realmUsersIdRoleMappingsRealmCompositeGet(requestParameters: RealmUsersIdRoleMappingsRealmCompositeGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmUsersIdRoleMappingsRealmCompositeGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Delete realm-level role mappings
+     */
+    async realmUsersIdRoleMappingsRealmDeleteRaw(requestParameters: RealmUsersIdRoleMappingsRealmDeleteRequest): 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 realmUsersIdRoleMappingsRealmDelete.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUsersIdRoleMappingsRealmDelete.');
+        }
+
+        if (requestParameters.roleRepresentation === null || requestParameters.roleRepresentation === undefined) {
+            throw new runtime.RequiredError('roleRepresentation','Required parameter requestParameters.roleRepresentation was null or undefined when calling realmUsersIdRoleMappingsRealmDelete.');
+        }
+
+        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/{id}/role-mappings/realm`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.roleRepresentation.map(RoleRepresentationToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete realm-level role mappings
+     */
+    async realmUsersIdRoleMappingsRealmDelete(requestParameters: RealmUsersIdRoleMappingsRealmDeleteRequest): Promise<void> {
+        await this.realmUsersIdRoleMappingsRealmDeleteRaw(requestParameters);
+    }
+
+    /**
+     * Get realm-level role mappings
+     */
+    async realmUsersIdRoleMappingsRealmGetRaw(requestParameters: RealmUsersIdRoleMappingsRealmGetRequest): 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 realmUsersIdRoleMappingsRealmGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUsersIdRoleMappingsRealmGet.');
+        }
+
+        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/{id}/role-mappings/realm`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get realm-level role mappings
+     */
+    async realmUsersIdRoleMappingsRealmGet(requestParameters: RealmUsersIdRoleMappingsRealmGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmUsersIdRoleMappingsRealmGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Add realm-level role mappings to the user
+     */
+    async realmUsersIdRoleMappingsRealmPostRaw(requestParameters: RealmUsersIdRoleMappingsRealmPostRequest): 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 realmUsersIdRoleMappingsRealmPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUsersIdRoleMappingsRealmPost.');
+        }
+
+        if (requestParameters.roleRepresentation === null || requestParameters.roleRepresentation === undefined) {
+            throw new runtime.RequiredError('roleRepresentation','Required parameter requestParameters.roleRepresentation was null or undefined when calling realmUsersIdRoleMappingsRealmPost.');
+        }
+
+        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/{id}/role-mappings/realm`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.roleRepresentation.map(RoleRepresentationToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Add realm-level role mappings to the user
+     */
+    async realmUsersIdRoleMappingsRealmPost(requestParameters: RealmUsersIdRoleMappingsRealmPostRequest): Promise<void> {
+        await this.realmUsersIdRoleMappingsRealmPostRaw(requestParameters);
+    }
+
+}

backend/keycloak/kc-client/apis/RolesByIDApi.ts

@@ -0,0 +1,549 @@
+/* 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 {
+    ManagementPermissionReference,
+    ManagementPermissionReferenceFromJSON,
+    ManagementPermissionReferenceToJSON,
+    RoleRepresentation,
+    RoleRepresentationFromJSON,
+    RoleRepresentationToJSON,
+} from '../models';
+
+export interface RealmRolesByIdRoleIdCompositesClientsClientUuidGetRequest {
+    realm: string;
+    roleId: string;
+    clientUuid: string;
+}
+
+export interface RealmRolesByIdRoleIdCompositesDeleteRequest {
+    realm: string;
+    roleId: string;
+    roleRepresentation: Array<RoleRepresentation>;
+}
+
+export interface RealmRolesByIdRoleIdCompositesGetRequest {
+    realm: string;
+    roleId: string;
+    first?: number;
+    max?: number;
+    search?: string;
+}
+
+export interface RealmRolesByIdRoleIdCompositesPostRequest {
+    realm: string;
+    roleId: string;
+    roleRepresentation: Array<RoleRepresentation>;
+}
+
+export interface RealmRolesByIdRoleIdCompositesRealmGetRequest {
+    realm: string;
+    roleId: string;
+}
+
+export interface RealmRolesByIdRoleIdDeleteRequest {
+    realm: string;
+    roleId: string;
+}
+
+export interface RealmRolesByIdRoleIdGetRequest {
+    realm: string;
+    roleId: string;
+}
+
+export interface RealmRolesByIdRoleIdManagementPermissionsGetRequest {
+    realm: string;
+    roleId: string;
+}
+
+export interface RealmRolesByIdRoleIdManagementPermissionsPutRequest {
+    realm: string;
+    roleId: string;
+    managementPermissionReference: ManagementPermissionReference;
+}
+
+export interface RealmRolesByIdRoleIdPutRequest {
+    realm: string;
+    roleId: string;
+    roleRepresentation: RoleRepresentation;
+}
+
+/**
+ * 
+ */
+export class RolesByIDApi extends runtime.BaseAPI {
+
+    /**
+     * Get client-level roles for the client that are in the role’s composite
+     */
+    async realmRolesByIdRoleIdCompositesClientsClientUuidGetRaw(requestParameters: RealmRolesByIdRoleIdCompositesClientsClientUuidGetRequest): 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 realmRolesByIdRoleIdCompositesClientsClientUuidGet.');
+        }
+
+        if (requestParameters.roleId === null || requestParameters.roleId === undefined) {
+            throw new runtime.RequiredError('roleId','Required parameter requestParameters.roleId was null or undefined when calling realmRolesByIdRoleIdCompositesClientsClientUuidGet.');
+        }
+
+        if (requestParameters.clientUuid === null || requestParameters.clientUuid === undefined) {
+            throw new runtime.RequiredError('clientUuid','Required parameter requestParameters.clientUuid was null or undefined when calling realmRolesByIdRoleIdCompositesClientsClientUuidGet.');
+        }
+
+        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}/roles-by-id/{role-id}/composites/clients/{clientUuid}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"role-id"}}`, encodeURIComponent(String(requestParameters.roleId))).replace(`{${"clientUuid"}}`, encodeURIComponent(String(requestParameters.clientUuid))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get client-level roles for the client that are in the role’s composite
+     */
+    async realmRolesByIdRoleIdCompositesClientsClientUuidGet(requestParameters: RealmRolesByIdRoleIdCompositesClientsClientUuidGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmRolesByIdRoleIdCompositesClientsClientUuidGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Remove a set of roles from the role’s composite
+     */
+    async realmRolesByIdRoleIdCompositesDeleteRaw(requestParameters: RealmRolesByIdRoleIdCompositesDeleteRequest): 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 realmRolesByIdRoleIdCompositesDelete.');
+        }
+
+        if (requestParameters.roleId === null || requestParameters.roleId === undefined) {
+            throw new runtime.RequiredError('roleId','Required parameter requestParameters.roleId was null or undefined when calling realmRolesByIdRoleIdCompositesDelete.');
+        }
+
+        if (requestParameters.roleRepresentation === null || requestParameters.roleRepresentation === undefined) {
+            throw new runtime.RequiredError('roleRepresentation','Required parameter requestParameters.roleRepresentation was null or undefined when calling realmRolesByIdRoleIdCompositesDelete.');
+        }
+
+        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}/roles-by-id/{role-id}/composites`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"role-id"}}`, encodeURIComponent(String(requestParameters.roleId))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.roleRepresentation.map(RoleRepresentationToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Remove a set of roles from the role’s composite
+     */
+    async realmRolesByIdRoleIdCompositesDelete(requestParameters: RealmRolesByIdRoleIdCompositesDeleteRequest): Promise<void> {
+        await this.realmRolesByIdRoleIdCompositesDeleteRaw(requestParameters);
+    }
+
+    /**
+     * Get role’s children   Returns a set of role’s children provided the role is a composite.
+     */
+    async realmRolesByIdRoleIdCompositesGetRaw(requestParameters: RealmRolesByIdRoleIdCompositesGetRequest): 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 realmRolesByIdRoleIdCompositesGet.');
+        }
+
+        if (requestParameters.roleId === null || requestParameters.roleId === undefined) {
+            throw new runtime.RequiredError('roleId','Required parameter requestParameters.roleId was null or undefined when calling realmRolesByIdRoleIdCompositesGet.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.first !== undefined) {
+            queryParameters['first'] = requestParameters.first;
+        }
+
+        if (requestParameters.max !== undefined) {
+            queryParameters['max'] = requestParameters.max;
+        }
+
+        if (requestParameters.search !== undefined) {
+            queryParameters['search'] = requestParameters.search;
+        }
+
+        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}/roles-by-id/{role-id}/composites`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"role-id"}}`, encodeURIComponent(String(requestParameters.roleId))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get role’s children   Returns a set of role’s children provided the role is a composite.
+     */
+    async realmRolesByIdRoleIdCompositesGet(requestParameters: RealmRolesByIdRoleIdCompositesGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmRolesByIdRoleIdCompositesGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Make the role a composite role by associating some child roles
+     */
+    async realmRolesByIdRoleIdCompositesPostRaw(requestParameters: RealmRolesByIdRoleIdCompositesPostRequest): 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 realmRolesByIdRoleIdCompositesPost.');
+        }
+
+        if (requestParameters.roleId === null || requestParameters.roleId === undefined) {
+            throw new runtime.RequiredError('roleId','Required parameter requestParameters.roleId was null or undefined when calling realmRolesByIdRoleIdCompositesPost.');
+        }
+
+        if (requestParameters.roleRepresentation === null || requestParameters.roleRepresentation === undefined) {
+            throw new runtime.RequiredError('roleRepresentation','Required parameter requestParameters.roleRepresentation was null or undefined when calling realmRolesByIdRoleIdCompositesPost.');
+        }
+
+        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}/roles-by-id/{role-id}/composites`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"role-id"}}`, encodeURIComponent(String(requestParameters.roleId))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.roleRepresentation.map(RoleRepresentationToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Make the role a composite role by associating some child roles
+     */
+    async realmRolesByIdRoleIdCompositesPost(requestParameters: RealmRolesByIdRoleIdCompositesPostRequest): Promise<void> {
+        await this.realmRolesByIdRoleIdCompositesPostRaw(requestParameters);
+    }
+
+    /**
+     * Get realm-level roles that are in the role’s composite
+     */
+    async realmRolesByIdRoleIdCompositesRealmGetRaw(requestParameters: RealmRolesByIdRoleIdCompositesRealmGetRequest): 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 realmRolesByIdRoleIdCompositesRealmGet.');
+        }
+
+        if (requestParameters.roleId === null || requestParameters.roleId === undefined) {
+            throw new runtime.RequiredError('roleId','Required parameter requestParameters.roleId was null or undefined when calling realmRolesByIdRoleIdCompositesRealmGet.');
+        }
+
+        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}/roles-by-id/{role-id}/composites/realm`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"role-id"}}`, encodeURIComponent(String(requestParameters.roleId))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get realm-level roles that are in the role’s composite
+     */
+    async realmRolesByIdRoleIdCompositesRealmGet(requestParameters: RealmRolesByIdRoleIdCompositesRealmGetRequest): Promise<Array<{ [key: string]: object; }>> {
+        const response = await this.realmRolesByIdRoleIdCompositesRealmGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Delete the role
+     */
+    async realmRolesByIdRoleIdDeleteRaw(requestParameters: RealmRolesByIdRoleIdDeleteRequest): 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 realmRolesByIdRoleIdDelete.');
+        }
+
+        if (requestParameters.roleId === null || requestParameters.roleId === undefined) {
+            throw new runtime.RequiredError('roleId','Required parameter requestParameters.roleId was null or undefined when calling realmRolesByIdRoleIdDelete.');
+        }
+
+        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}/roles-by-id/{role-id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"role-id"}}`, encodeURIComponent(String(requestParameters.roleId))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete the role
+     */
+    async realmRolesByIdRoleIdDelete(requestParameters: RealmRolesByIdRoleIdDeleteRequest): Promise<void> {
+        await this.realmRolesByIdRoleIdDeleteRaw(requestParameters);
+    }
+
+    /**
+     * Get a specific role’s representation
+     */
+    async realmRolesByIdRoleIdGetRaw(requestParameters: RealmRolesByIdRoleIdGetRequest): Promise<runtime.ApiResponse<RoleRepresentation>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmRolesByIdRoleIdGet.');
+        }
+
+        if (requestParameters.roleId === null || requestParameters.roleId === undefined) {
+            throw new runtime.RequiredError('roleId','Required parameter requestParameters.roleId was null or undefined when calling realmRolesByIdRoleIdGet.');
+        }
+
+        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}/roles-by-id/{role-id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"role-id"}}`, encodeURIComponent(String(requestParameters.roleId))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RoleRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Get a specific role’s representation
+     */
+    async realmRolesByIdRoleIdGet(requestParameters: RealmRolesByIdRoleIdGetRequest): Promise<RoleRepresentation> {
+        const response = await this.realmRolesByIdRoleIdGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Return object stating whether role Authoirzation permissions have been initialized or not and a reference
+     */
+    async realmRolesByIdRoleIdManagementPermissionsGetRaw(requestParameters: RealmRolesByIdRoleIdManagementPermissionsGetRequest): 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 realmRolesByIdRoleIdManagementPermissionsGet.');
+        }
+
+        if (requestParameters.roleId === null || requestParameters.roleId === undefined) {
+            throw new runtime.RequiredError('roleId','Required parameter requestParameters.roleId was null or undefined when calling realmRolesByIdRoleIdManagementPermissionsGet.');
+        }
+
+        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}/roles-by-id/{role-id}/management/permissions`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"role-id"}}`, encodeURIComponent(String(requestParameters.roleId))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ManagementPermissionReferenceFromJSON(jsonValue));
+    }
+
+    /**
+     * Return object stating whether role Authoirzation permissions have been initialized or not and a reference
+     */
+    async realmRolesByIdRoleIdManagementPermissionsGet(requestParameters: RealmRolesByIdRoleIdManagementPermissionsGetRequest): Promise<ManagementPermissionReference> {
+        const response = await this.realmRolesByIdRoleIdManagementPermissionsGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Return object stating whether role Authoirzation permissions have been initialized or not and a reference
+     */
+    async realmRolesByIdRoleIdManagementPermissionsPutRaw(requestParameters: RealmRolesByIdRoleIdManagementPermissionsPutRequest): 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 realmRolesByIdRoleIdManagementPermissionsPut.');
+        }
+
+        if (requestParameters.roleId === null || requestParameters.roleId === undefined) {
+            throw new runtime.RequiredError('roleId','Required parameter requestParameters.roleId was null or undefined when calling realmRolesByIdRoleIdManagementPermissionsPut.');
+        }
+
+        if (requestParameters.managementPermissionReference === null || requestParameters.managementPermissionReference === undefined) {
+            throw new runtime.RequiredError('managementPermissionReference','Required parameter requestParameters.managementPermissionReference was null or undefined when calling realmRolesByIdRoleIdManagementPermissionsPut.');
+        }
+
+        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}/roles-by-id/{role-id}/management/permissions`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"role-id"}}`, encodeURIComponent(String(requestParameters.roleId))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ManagementPermissionReferenceToJSON(requestParameters.managementPermissionReference),
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ManagementPermissionReferenceFromJSON(jsonValue));
+    }
+
+    /**
+     * Return object stating whether role Authoirzation permissions have been initialized or not and a reference
+     */
+    async realmRolesByIdRoleIdManagementPermissionsPut(requestParameters: RealmRolesByIdRoleIdManagementPermissionsPutRequest): Promise<ManagementPermissionReference> {
+        const response = await this.realmRolesByIdRoleIdManagementPermissionsPutRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Update the role
+     */
+    async realmRolesByIdRoleIdPutRaw(requestParameters: RealmRolesByIdRoleIdPutRequest): 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 realmRolesByIdRoleIdPut.');
+        }
+
+        if (requestParameters.roleId === null || requestParameters.roleId === undefined) {
+            throw new runtime.RequiredError('roleId','Required parameter requestParameters.roleId was null or undefined when calling realmRolesByIdRoleIdPut.');
+        }
+
+        if (requestParameters.roleRepresentation === null || requestParameters.roleRepresentation === undefined) {
+            throw new runtime.RequiredError('roleRepresentation','Required parameter requestParameters.roleRepresentation was null or undefined when calling realmRolesByIdRoleIdPut.');
+        }
+
+        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}/roles-by-id/{role-id}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"role-id"}}`, encodeURIComponent(String(requestParameters.roleId))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: RoleRepresentationToJSON(requestParameters.roleRepresentation),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Update the role
+     */
+    async realmRolesByIdRoleIdPut(requestParameters: RealmRolesByIdRoleIdPutRequest): Promise<void> {
+        await this.realmRolesByIdRoleIdPutRaw(requestParameters);
+    }
+
+}

backend/keycloak/kc-client/apis/RootApi.ts

@@ -0,0 +1,62 @@
+/* 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 {
+    ServerInfoRepresentation,
+    ServerInfoRepresentationFromJSON,
+    ServerInfoRepresentationToJSON,
+} from '../models';
+
+/**
+ * 
+ */
+export class RootApi extends runtime.BaseAPI {
+
+    /**
+     * Get themes, social providers, auth providers, and event listeners available on this server
+     */
+    async rootGetRaw(): Promise<runtime.ApiResponse<ServerInfoRepresentation>> {
+        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: `/`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ServerInfoRepresentationFromJSON(jsonValue));
+    }
+
+    /**
+     * Get themes, social providers, auth providers, and event listeners available on this server
+     */
+    async rootGet(): Promise<ServerInfoRepresentation> {
+        const response = await this.rootGetRaw();
+        return await response.value();
+    }
+
+}

backend/keycloak/kc-client/apis/UserStorageProviderApi.ts

@@ -0,0 +1,318 @@
+/* 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 {
+    SynchronizationResult,
+    SynchronizationResultFromJSON,
+    SynchronizationResultToJSON,
+} from '../models';
+
+export interface IdNameGetRequest {
+    id: string;
+}
+
+export interface RealmUserStorageIdNameGetRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmUserStorageIdRemoveImportedUsersPostRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmUserStorageIdSyncPostRequest {
+    realm: string;
+    id: string;
+    action?: string;
+}
+
+export interface RealmUserStorageIdUnlinkUsersPostRequest {
+    realm: string;
+    id: string;
+}
+
+export interface RealmUserStorageParentIdMappersIdSyncPostRequest {
+    realm: string;
+    parentId: string;
+    id: string;
+    direction?: string;
+}
+
+/**
+ * 
+ */
+export class UserStorageProviderApi extends runtime.BaseAPI {
+
+    /**
+     * Need this for admin console to display simple name of provider when displaying client detail   KEYCLOAK-4328
+     */
+    async idNameGetRaw(requestParameters: IdNameGetRequest): Promise<runtime.ApiResponse<{ [key: string]: object; }>> {
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling idNameGet.');
+        }
+
+        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: `/{id}/name`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Need this for admin console to display simple name of provider when displaying client detail   KEYCLOAK-4328
+     */
+    async idNameGet(requestParameters: IdNameGetRequest): Promise<{ [key: string]: object; }> {
+        const response = await this.idNameGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Need this for admin console to display simple name of provider when displaying user detail   KEYCLOAK-4328
+     */
+    async realmUserStorageIdNameGetRaw(requestParameters: RealmUserStorageIdNameGetRequest): 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 realmUserStorageIdNameGet.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUserStorageIdNameGet.');
+        }
+
+        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}/user-storage/{id}/name`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Need this for admin console to display simple name of provider when displaying user detail   KEYCLOAK-4328
+     */
+    async realmUserStorageIdNameGet(requestParameters: RealmUserStorageIdNameGetRequest): Promise<{ [key: string]: object; }> {
+        const response = await this.realmUserStorageIdNameGetRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Remove imported users
+     */
+    async realmUserStorageIdRemoveImportedUsersPostRaw(requestParameters: RealmUserStorageIdRemoveImportedUsersPostRequest): 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 realmUserStorageIdRemoveImportedUsersPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUserStorageIdRemoveImportedUsersPost.');
+        }
+
+        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}/user-storage/{id}/remove-imported-users`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Remove imported users
+     */
+    async realmUserStorageIdRemoveImportedUsersPost(requestParameters: RealmUserStorageIdRemoveImportedUsersPostRequest): Promise<void> {
+        await this.realmUserStorageIdRemoveImportedUsersPostRaw(requestParameters);
+    }
+
+    /**
+     * Trigger sync of users   Action can be \"triggerFullSync\" or \"triggerChangedUsersSync\"
+     */
+    async realmUserStorageIdSyncPostRaw(requestParameters: RealmUserStorageIdSyncPostRequest): Promise<runtime.ApiResponse<SynchronizationResult>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmUserStorageIdSyncPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUserStorageIdSyncPost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.action !== undefined) {
+            queryParameters['action'] = requestParameters.action;
+        }
+
+        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}/user-storage/{id}/sync`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => SynchronizationResultFromJSON(jsonValue));
+    }
+
+    /**
+     * Trigger sync of users   Action can be \"triggerFullSync\" or \"triggerChangedUsersSync\"
+     */
+    async realmUserStorageIdSyncPost(requestParameters: RealmUserStorageIdSyncPostRequest): Promise<SynchronizationResult> {
+        const response = await this.realmUserStorageIdSyncPostRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Unlink imported users from a storage provider
+     */
+    async realmUserStorageIdUnlinkUsersPostRaw(requestParameters: RealmUserStorageIdUnlinkUsersPostRequest): 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 realmUserStorageIdUnlinkUsersPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUserStorageIdUnlinkUsersPost.');
+        }
+
+        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}/user-storage/{id}/unlink-users`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Unlink imported users from a storage provider
+     */
+    async realmUserStorageIdUnlinkUsersPost(requestParameters: RealmUserStorageIdUnlinkUsersPostRequest): Promise<void> {
+        await this.realmUserStorageIdUnlinkUsersPostRaw(requestParameters);
+    }
+
+    /**
+     * Trigger sync of mapper data related to ldap mapper (roles, groups, …​)   direction is \"fedToKeycloak\" or \"keycloakToFed\"
+     */
+    async realmUserStorageParentIdMappersIdSyncPostRaw(requestParameters: RealmUserStorageParentIdMappersIdSyncPostRequest): Promise<runtime.ApiResponse<SynchronizationResult>> {
+        if (requestParameters.realm === null || requestParameters.realm === undefined) {
+            throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmUserStorageParentIdMappersIdSyncPost.');
+        }
+
+        if (requestParameters.parentId === null || requestParameters.parentId === undefined) {
+            throw new runtime.RequiredError('parentId','Required parameter requestParameters.parentId was null or undefined when calling realmUserStorageParentIdMappersIdSyncPost.');
+        }
+
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling realmUserStorageParentIdMappersIdSyncPost.');
+        }
+
+        const queryParameters: runtime.HTTPQuery = {};
+
+        if (requestParameters.direction !== undefined) {
+            queryParameters['direction'] = requestParameters.direction;
+        }
+
+        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}/user-storage/{parentId}/mappers/{id}/sync`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"parentId"}}`, encodeURIComponent(String(requestParameters.parentId))).replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => SynchronizationResultFromJSON(jsonValue));
+    }
+
+    /**
+     * Trigger sync of mapper data related to ldap mapper (roles, groups, …​)   direction is \"fedToKeycloak\" or \"keycloakToFed\"
+     */
+    async realmUserStorageParentIdMappersIdSyncPost(requestParameters: RealmUserStorageParentIdMappersIdSyncPostRequest): Promise<SynchronizationResult> {
+        const response = await this.realmUserStorageParentIdMappersIdSyncPostRaw(requestParameters);
+        return await response.value();
+    }
+
+}

backend/keycloak/kc-client/apis/index.ts

@@ -0,0 +1,21 @@
+export * from './AttackDetectionApi';
+export * from './AuthenticationManagementApi';
+export * from './ClientAttributeCertificateApi';
+export * from './ClientInitialAccessApi';
+export * from './ClientRegistrationPolicyApi';
+export * from './ClientRoleMappingsApi';
+export * from './ClientScopesApi';
+export * from './ClientsApi';
+export * from './ComponentApi';
+export * from './GroupsApi';
+export * from './IdentityProvidersApi';
+export * from './KeyApi';
+export * from './ProtocolMappersApi';
+export * from './RealmsAdminApi';
+export * from './RoleMapperApi';
+export * from './RolesApi';
+export * from './RolesByIDApi';
+export * from './RootApi';
+export * from './ScopeMappingsApi';
+export * from './UserStorageProviderApi';
+export * from './UsersApi';