2253 lines
93 KiB
TypeScript
2253 lines
93 KiB
TypeScript
/* tslint:disable */
|
||
/* eslint-disable */
|
||
/**
|
||
* Keycloak Admin REST API
|
||
* This is a REST API reference for the Keycloak Admin
|
||
*
|
||
* The version of the OpenAPI document: 1
|
||
*
|
||
*
|
||
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
|
||
* https://openapi-generator.tech
|
||
* Do not edit the class manually.
|
||
*/
|
||
|
||
|
||
import * as runtime from '../runtime';
|
||
import {
|
||
ClientPoliciesRepresentation,
|
||
ClientPoliciesRepresentationFromJSON,
|
||
ClientPoliciesRepresentationToJSON,
|
||
ClientProfilesRepresentation,
|
||
ClientProfilesRepresentationFromJSON,
|
||
ClientProfilesRepresentationToJSON,
|
||
ClientRepresentation,
|
||
ClientRepresentationFromJSON,
|
||
ClientRepresentationToJSON,
|
||
GlobalRequestResult,
|
||
GlobalRequestResultFromJSON,
|
||
GlobalRequestResultToJSON,
|
||
GroupRepresentation,
|
||
GroupRepresentationFromJSON,
|
||
GroupRepresentationToJSON,
|
||
ManagementPermissionReference,
|
||
ManagementPermissionReferenceFromJSON,
|
||
ManagementPermissionReferenceToJSON,
|
||
PartialImportRepresentation,
|
||
PartialImportRepresentationFromJSON,
|
||
PartialImportRepresentationToJSON,
|
||
RealmEventsConfigRepresentation,
|
||
RealmEventsConfigRepresentationFromJSON,
|
||
RealmEventsConfigRepresentationToJSON,
|
||
RealmRepresentation,
|
||
RealmRepresentationFromJSON,
|
||
RealmRepresentationToJSON,
|
||
TestLdapConnectionRepresentation,
|
||
TestLdapConnectionRepresentationFromJSON,
|
||
TestLdapConnectionRepresentationToJSON,
|
||
} from '../models';
|
||
|
||
export interface RealmAdminEventsDeleteRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmAdminEventsGetRequest {
|
||
realm: string;
|
||
authClient?: string;
|
||
authIpAddress?: string;
|
||
authRealm?: string;
|
||
authUser?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
first?: number;
|
||
max?: number;
|
||
operationTypes?: Array<string>;
|
||
resourcePath?: string;
|
||
resourceTypes?: Array<string>;
|
||
}
|
||
|
||
export interface RealmClearKeysCachePostRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmClearRealmCachePostRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmClearUserCachePostRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmClientDescriptionConverterPostRequest {
|
||
realm: string;
|
||
body: string;
|
||
}
|
||
|
||
export interface RealmClientPoliciesPoliciesGetRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmClientPoliciesPoliciesPutRequest {
|
||
realm: string;
|
||
clientPoliciesRepresentation: ClientPoliciesRepresentation;
|
||
}
|
||
|
||
export interface RealmClientPoliciesProfilesGetRequest {
|
||
realm: string;
|
||
includeGlobalProfiles?: boolean;
|
||
}
|
||
|
||
export interface RealmClientPoliciesProfilesPutRequest {
|
||
realm: string;
|
||
clientProfilesRepresentation: ClientProfilesRepresentation;
|
||
}
|
||
|
||
export interface RealmClientSessionStatsGetRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmCredentialRegistratorsGetRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmDefaultDefaultClientScopesClientScopeIdDeleteRequest {
|
||
realm: string;
|
||
clientScopeId: string;
|
||
}
|
||
|
||
export interface RealmDefaultDefaultClientScopesClientScopeIdPutRequest {
|
||
realm: string;
|
||
clientScopeId: string;
|
||
}
|
||
|
||
export interface RealmDefaultDefaultClientScopesGetRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmDefaultGroupsGetRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmDefaultGroupsGroupIdDeleteRequest {
|
||
realm: string;
|
||
groupId: string;
|
||
}
|
||
|
||
export interface RealmDefaultGroupsGroupIdPutRequest {
|
||
realm: string;
|
||
groupId: string;
|
||
}
|
||
|
||
export interface RealmDefaultOptionalClientScopesClientScopeIdDeleteRequest {
|
||
realm: string;
|
||
clientScopeId: string;
|
||
}
|
||
|
||
export interface RealmDefaultOptionalClientScopesClientScopeIdPutRequest {
|
||
realm: string;
|
||
clientScopeId: string;
|
||
}
|
||
|
||
export interface RealmDefaultOptionalClientScopesGetRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmDeleteRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmEventsConfigGetRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmEventsConfigPutRequest {
|
||
realm: string;
|
||
realmEventsConfigRepresentation: RealmEventsConfigRepresentation;
|
||
}
|
||
|
||
export interface RealmEventsDeleteRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmEventsGetRequest {
|
||
realm: string;
|
||
client?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
first?: number;
|
||
ipAddress?: string;
|
||
max?: number;
|
||
type?: Array<string>;
|
||
user?: string;
|
||
}
|
||
|
||
export interface RealmGetRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmGroupByPathPathGetRequest {
|
||
realm: string;
|
||
path: string;
|
||
}
|
||
|
||
export interface RealmLdapServerCapabilitiesPostRequest {
|
||
realm: string;
|
||
testLdapConnectionRepresentation: TestLdapConnectionRepresentation;
|
||
}
|
||
|
||
export interface RealmLocalizationGetRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmLocalizationLocaleDeleteRequest {
|
||
realm: string;
|
||
locale: string;
|
||
}
|
||
|
||
export interface RealmLocalizationLocaleGetRequest {
|
||
realm: string;
|
||
locale: string;
|
||
}
|
||
|
||
export interface RealmLocalizationLocaleKeyDeleteRequest {
|
||
realm: string;
|
||
locale: string;
|
||
key: string;
|
||
}
|
||
|
||
export interface RealmLocalizationLocaleKeyGetRequest {
|
||
realm: string;
|
||
locale: string;
|
||
key: string;
|
||
}
|
||
|
||
export interface RealmLocalizationLocaleKeyPutRequest {
|
||
realm: string;
|
||
locale: string;
|
||
key: string;
|
||
body: string;
|
||
}
|
||
|
||
export interface RealmLocalizationLocalePostRequest {
|
||
realm: string;
|
||
locale: string;
|
||
requestBody: { [key: string]: object; };
|
||
}
|
||
|
||
export interface RealmLogoutAllPostRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmPartialExportPostRequest {
|
||
realm: string;
|
||
exportClients?: boolean;
|
||
exportGroupsAndRoles?: boolean;
|
||
}
|
||
|
||
export interface RealmPartialImportPostRequest {
|
||
realm: string;
|
||
partialImportRepresentation: PartialImportRepresentation;
|
||
}
|
||
|
||
export interface RealmPushRevocationPostRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmPutRequest {
|
||
realm: string;
|
||
realmRepresentation: RealmRepresentation;
|
||
}
|
||
|
||
export interface RealmSessionsSessionDeleteRequest {
|
||
realm: string;
|
||
session: string;
|
||
}
|
||
|
||
export interface RealmTestLDAPConnectionPostRequest {
|
||
realm: string;
|
||
testLdapConnectionRepresentation: TestLdapConnectionRepresentation;
|
||
}
|
||
|
||
export interface RealmTestSMTPConnectionPostRequest {
|
||
realm: string;
|
||
requestBody: { [key: string]: object; };
|
||
}
|
||
|
||
export interface RealmUsersManagementPermissionsGetRequest {
|
||
realm: string;
|
||
}
|
||
|
||
export interface RealmUsersManagementPermissionsPutRequest {
|
||
realm: string;
|
||
managementPermissionReference: ManagementPermissionReference;
|
||
}
|
||
|
||
export interface RootPostRequest {
|
||
realmRepresentation: RealmRepresentation;
|
||
}
|
||
|
||
/**
|
||
*
|
||
*/
|
||
export class RealmsAdminApi extends runtime.BaseAPI {
|
||
|
||
/**
|
||
* Delete all admin events
|
||
*/
|
||
async realmAdminEventsDeleteRaw(requestParameters: RealmAdminEventsDeleteRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmAdminEventsDelete.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/admin-events`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'DELETE',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Delete all admin events
|
||
*/
|
||
async realmAdminEventsDelete(requestParameters: RealmAdminEventsDeleteRequest): Promise<void> {
|
||
await this.realmAdminEventsDeleteRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Get admin events Returns all admin events, or filters events based on URL query parameters listed here
|
||
*/
|
||
async realmAdminEventsGetRaw(requestParameters: RealmAdminEventsGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmAdminEventsGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
if (requestParameters.authClient !== undefined) {
|
||
queryParameters['authClient'] = requestParameters.authClient;
|
||
}
|
||
|
||
if (requestParameters.authIpAddress !== undefined) {
|
||
queryParameters['authIpAddress'] = requestParameters.authIpAddress;
|
||
}
|
||
|
||
if (requestParameters.authRealm !== undefined) {
|
||
queryParameters['authRealm'] = requestParameters.authRealm;
|
||
}
|
||
|
||
if (requestParameters.authUser !== undefined) {
|
||
queryParameters['authUser'] = requestParameters.authUser;
|
||
}
|
||
|
||
if (requestParameters.dateFrom !== undefined) {
|
||
queryParameters['dateFrom'] = requestParameters.dateFrom;
|
||
}
|
||
|
||
if (requestParameters.dateTo !== undefined) {
|
||
queryParameters['dateTo'] = requestParameters.dateTo;
|
||
}
|
||
|
||
if (requestParameters.first !== undefined) {
|
||
queryParameters['first'] = requestParameters.first;
|
||
}
|
||
|
||
if (requestParameters.max !== undefined) {
|
||
queryParameters['max'] = requestParameters.max;
|
||
}
|
||
|
||
if (requestParameters.operationTypes) {
|
||
queryParameters['operationTypes'] = requestParameters.operationTypes;
|
||
}
|
||
|
||
if (requestParameters.resourcePath !== undefined) {
|
||
queryParameters['resourcePath'] = requestParameters.resourcePath;
|
||
}
|
||
|
||
if (requestParameters.resourceTypes) {
|
||
queryParameters['resourceTypes'] = requestParameters.resourceTypes;
|
||
}
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/admin-events`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse<any>(response);
|
||
}
|
||
|
||
/**
|
||
* Get admin events Returns all admin events, or filters events based on URL query parameters listed here
|
||
*/
|
||
async realmAdminEventsGet(requestParameters: RealmAdminEventsGetRequest): Promise<Array<{ [key: string]: object; }>> {
|
||
const response = await this.realmAdminEventsGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
* Clear cache of external public keys (Public keys of clients or Identity providers)
|
||
*/
|
||
async realmClearKeysCachePostRaw(requestParameters: RealmClearKeysCachePostRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClearKeysCachePost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/clear-keys-cache`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Clear cache of external public keys (Public keys of clients or Identity providers)
|
||
*/
|
||
async realmClearKeysCachePost(requestParameters: RealmClearKeysCachePostRequest): Promise<void> {
|
||
await this.realmClearKeysCachePostRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Clear realm cache
|
||
*/
|
||
async realmClearRealmCachePostRaw(requestParameters: RealmClearRealmCachePostRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClearRealmCachePost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/clear-realm-cache`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Clear realm cache
|
||
*/
|
||
async realmClearRealmCachePost(requestParameters: RealmClearRealmCachePostRequest): Promise<void> {
|
||
await this.realmClearRealmCachePostRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Clear user cache
|
||
*/
|
||
async realmClearUserCachePostRaw(requestParameters: RealmClearUserCachePostRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClearUserCachePost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/clear-user-cache`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Clear user cache
|
||
*/
|
||
async realmClearUserCachePost(requestParameters: RealmClearUserCachePostRequest): Promise<void> {
|
||
await this.realmClearUserCachePostRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Base path for importing clients under this realm.
|
||
*/
|
||
async realmClientDescriptionConverterPostRaw(requestParameters: RealmClientDescriptionConverterPostRequest): Promise<runtime.ApiResponse<ClientRepresentation>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientDescriptionConverterPost.');
|
||
}
|
||
|
||
if (requestParameters.body === null || requestParameters.body === undefined) {
|
||
throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling realmClientDescriptionConverterPost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'text/plain';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/client-description-converter`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: requestParameters.body as any,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse(response, (jsonValue) => ClientRepresentationFromJSON(jsonValue));
|
||
}
|
||
|
||
/**
|
||
* Base path for importing clients under this realm.
|
||
*/
|
||
async realmClientDescriptionConverterPost(requestParameters: RealmClientDescriptionConverterPostRequest): Promise<ClientRepresentation> {
|
||
const response = await this.realmClientDescriptionConverterPostRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmClientPoliciesPoliciesGetRaw(requestParameters: RealmClientPoliciesPoliciesGetRequest): Promise<runtime.ApiResponse<ClientPoliciesRepresentation>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientPoliciesPoliciesGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/client-policies/policies`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse(response, (jsonValue) => ClientPoliciesRepresentationFromJSON(jsonValue));
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmClientPoliciesPoliciesGet(requestParameters: RealmClientPoliciesPoliciesGetRequest): Promise<ClientPoliciesRepresentation> {
|
||
const response = await this.realmClientPoliciesPoliciesGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmClientPoliciesPoliciesPutRaw(requestParameters: RealmClientPoliciesPoliciesPutRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientPoliciesPoliciesPut.');
|
||
}
|
||
|
||
if (requestParameters.clientPoliciesRepresentation === null || requestParameters.clientPoliciesRepresentation === undefined) {
|
||
throw new runtime.RequiredError('clientPoliciesRepresentation','Required parameter requestParameters.clientPoliciesRepresentation was null or undefined when calling realmClientPoliciesPoliciesPut.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'application/json';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/client-policies/policies`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'PUT',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: ClientPoliciesRepresentationToJSON(requestParameters.clientPoliciesRepresentation),
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmClientPoliciesPoliciesPut(requestParameters: RealmClientPoliciesPoliciesPutRequest): Promise<void> {
|
||
await this.realmClientPoliciesPoliciesPutRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmClientPoliciesProfilesGetRaw(requestParameters: RealmClientPoliciesProfilesGetRequest): Promise<runtime.ApiResponse<ClientProfilesRepresentation>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientPoliciesProfilesGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
if (requestParameters.includeGlobalProfiles !== undefined) {
|
||
queryParameters['include-global-profiles'] = requestParameters.includeGlobalProfiles;
|
||
}
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/client-policies/profiles`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse(response, (jsonValue) => ClientProfilesRepresentationFromJSON(jsonValue));
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmClientPoliciesProfilesGet(requestParameters: RealmClientPoliciesProfilesGetRequest): Promise<ClientProfilesRepresentation> {
|
||
const response = await this.realmClientPoliciesProfilesGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmClientPoliciesProfilesPutRaw(requestParameters: RealmClientPoliciesProfilesPutRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientPoliciesProfilesPut.');
|
||
}
|
||
|
||
if (requestParameters.clientProfilesRepresentation === null || requestParameters.clientProfilesRepresentation === undefined) {
|
||
throw new runtime.RequiredError('clientProfilesRepresentation','Required parameter requestParameters.clientProfilesRepresentation was null or undefined when calling realmClientPoliciesProfilesPut.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'application/json';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/client-policies/profiles`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'PUT',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: ClientProfilesRepresentationToJSON(requestParameters.clientProfilesRepresentation),
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmClientPoliciesProfilesPut(requestParameters: RealmClientPoliciesProfilesPutRequest): Promise<void> {
|
||
await this.realmClientPoliciesProfilesPutRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Get client session stats Returns a JSON map.
|
||
*/
|
||
async realmClientSessionStatsGetRaw(requestParameters: RealmClientSessionStatsGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmClientSessionStatsGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/client-session-stats`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse<any>(response);
|
||
}
|
||
|
||
/**
|
||
* Get client session stats Returns a JSON map.
|
||
*/
|
||
async realmClientSessionStatsGet(requestParameters: RealmClientSessionStatsGetRequest): Promise<Array<{ [key: string]: object; }>> {
|
||
const response = await this.realmClientSessionStatsGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmCredentialRegistratorsGetRaw(requestParameters: RealmCredentialRegistratorsGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmCredentialRegistratorsGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/credential-registrators`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse<any>(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmCredentialRegistratorsGet(requestParameters: RealmCredentialRegistratorsGetRequest): Promise<Array<{ [key: string]: object; }>> {
|
||
const response = await this.realmCredentialRegistratorsGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmDefaultDefaultClientScopesClientScopeIdDeleteRaw(requestParameters: RealmDefaultDefaultClientScopesClientScopeIdDeleteRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmDefaultDefaultClientScopesClientScopeIdDelete.');
|
||
}
|
||
|
||
if (requestParameters.clientScopeId === null || requestParameters.clientScopeId === undefined) {
|
||
throw new runtime.RequiredError('clientScopeId','Required parameter requestParameters.clientScopeId was null or undefined when calling realmDefaultDefaultClientScopesClientScopeIdDelete.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/default-default-client-scopes/{clientScopeId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"clientScopeId"}}`, encodeURIComponent(String(requestParameters.clientScopeId))),
|
||
method: 'DELETE',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmDefaultDefaultClientScopesClientScopeIdDelete(requestParameters: RealmDefaultDefaultClientScopesClientScopeIdDeleteRequest): Promise<void> {
|
||
await this.realmDefaultDefaultClientScopesClientScopeIdDeleteRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmDefaultDefaultClientScopesClientScopeIdPutRaw(requestParameters: RealmDefaultDefaultClientScopesClientScopeIdPutRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmDefaultDefaultClientScopesClientScopeIdPut.');
|
||
}
|
||
|
||
if (requestParameters.clientScopeId === null || requestParameters.clientScopeId === undefined) {
|
||
throw new runtime.RequiredError('clientScopeId','Required parameter requestParameters.clientScopeId was null or undefined when calling realmDefaultDefaultClientScopesClientScopeIdPut.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/default-default-client-scopes/{clientScopeId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"clientScopeId"}}`, encodeURIComponent(String(requestParameters.clientScopeId))),
|
||
method: 'PUT',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmDefaultDefaultClientScopesClientScopeIdPut(requestParameters: RealmDefaultDefaultClientScopesClientScopeIdPutRequest): Promise<void> {
|
||
await this.realmDefaultDefaultClientScopesClientScopeIdPutRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Get realm default client scopes.
|
||
*/
|
||
async realmDefaultDefaultClientScopesGetRaw(requestParameters: RealmDefaultDefaultClientScopesGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmDefaultDefaultClientScopesGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/default-default-client-scopes`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse<any>(response);
|
||
}
|
||
|
||
/**
|
||
* Get realm default client scopes.
|
||
*/
|
||
async realmDefaultDefaultClientScopesGet(requestParameters: RealmDefaultDefaultClientScopesGetRequest): Promise<Array<{ [key: string]: object; }>> {
|
||
const response = await this.realmDefaultDefaultClientScopesGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
* Get group hierarchy.
|
||
*/
|
||
async realmDefaultGroupsGetRaw(requestParameters: RealmDefaultGroupsGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmDefaultGroupsGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/default-groups`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse<any>(response);
|
||
}
|
||
|
||
/**
|
||
* Get group hierarchy.
|
||
*/
|
||
async realmDefaultGroupsGet(requestParameters: RealmDefaultGroupsGetRequest): Promise<Array<{ [key: string]: object; }>> {
|
||
const response = await this.realmDefaultGroupsGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmDefaultGroupsGroupIdDeleteRaw(requestParameters: RealmDefaultGroupsGroupIdDeleteRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmDefaultGroupsGroupIdDelete.');
|
||
}
|
||
|
||
if (requestParameters.groupId === null || requestParameters.groupId === undefined) {
|
||
throw new runtime.RequiredError('groupId','Required parameter requestParameters.groupId was null or undefined when calling realmDefaultGroupsGroupIdDelete.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/default-groups/{groupId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"groupId"}}`, encodeURIComponent(String(requestParameters.groupId))),
|
||
method: 'DELETE',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmDefaultGroupsGroupIdDelete(requestParameters: RealmDefaultGroupsGroupIdDeleteRequest): Promise<void> {
|
||
await this.realmDefaultGroupsGroupIdDeleteRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmDefaultGroupsGroupIdPutRaw(requestParameters: RealmDefaultGroupsGroupIdPutRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmDefaultGroupsGroupIdPut.');
|
||
}
|
||
|
||
if (requestParameters.groupId === null || requestParameters.groupId === undefined) {
|
||
throw new runtime.RequiredError('groupId','Required parameter requestParameters.groupId was null or undefined when calling realmDefaultGroupsGroupIdPut.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/default-groups/{groupId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"groupId"}}`, encodeURIComponent(String(requestParameters.groupId))),
|
||
method: 'PUT',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmDefaultGroupsGroupIdPut(requestParameters: RealmDefaultGroupsGroupIdPutRequest): Promise<void> {
|
||
await this.realmDefaultGroupsGroupIdPutRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmDefaultOptionalClientScopesClientScopeIdDeleteRaw(requestParameters: RealmDefaultOptionalClientScopesClientScopeIdDeleteRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmDefaultOptionalClientScopesClientScopeIdDelete.');
|
||
}
|
||
|
||
if (requestParameters.clientScopeId === null || requestParameters.clientScopeId === undefined) {
|
||
throw new runtime.RequiredError('clientScopeId','Required parameter requestParameters.clientScopeId was null or undefined when calling realmDefaultOptionalClientScopesClientScopeIdDelete.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/default-optional-client-scopes/{clientScopeId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"clientScopeId"}}`, encodeURIComponent(String(requestParameters.clientScopeId))),
|
||
method: 'DELETE',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmDefaultOptionalClientScopesClientScopeIdDelete(requestParameters: RealmDefaultOptionalClientScopesClientScopeIdDeleteRequest): Promise<void> {
|
||
await this.realmDefaultOptionalClientScopesClientScopeIdDeleteRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmDefaultOptionalClientScopesClientScopeIdPutRaw(requestParameters: RealmDefaultOptionalClientScopesClientScopeIdPutRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmDefaultOptionalClientScopesClientScopeIdPut.');
|
||
}
|
||
|
||
if (requestParameters.clientScopeId === null || requestParameters.clientScopeId === undefined) {
|
||
throw new runtime.RequiredError('clientScopeId','Required parameter requestParameters.clientScopeId was null or undefined when calling realmDefaultOptionalClientScopesClientScopeIdPut.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/default-optional-client-scopes/{clientScopeId}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"clientScopeId"}}`, encodeURIComponent(String(requestParameters.clientScopeId))),
|
||
method: 'PUT',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmDefaultOptionalClientScopesClientScopeIdPut(requestParameters: RealmDefaultOptionalClientScopesClientScopeIdPutRequest): Promise<void> {
|
||
await this.realmDefaultOptionalClientScopesClientScopeIdPutRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Get realm optional client scopes.
|
||
*/
|
||
async realmDefaultOptionalClientScopesGetRaw(requestParameters: RealmDefaultOptionalClientScopesGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmDefaultOptionalClientScopesGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/default-optional-client-scopes`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse<any>(response);
|
||
}
|
||
|
||
/**
|
||
* Get realm optional client scopes.
|
||
*/
|
||
async realmDefaultOptionalClientScopesGet(requestParameters: RealmDefaultOptionalClientScopesGetRequest): Promise<Array<{ [key: string]: object; }>> {
|
||
const response = await this.realmDefaultOptionalClientScopesGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
* Delete the realm
|
||
*/
|
||
async realmDeleteRaw(requestParameters: RealmDeleteRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmDelete.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'DELETE',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Delete the realm
|
||
*/
|
||
async realmDelete(requestParameters: RealmDeleteRequest): Promise<void> {
|
||
await this.realmDeleteRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Get the events provider configuration Returns JSON object with events provider configuration
|
||
*/
|
||
async realmEventsConfigGetRaw(requestParameters: RealmEventsConfigGetRequest): Promise<runtime.ApiResponse<RealmEventsConfigRepresentation>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmEventsConfigGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/events/config`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse(response, (jsonValue) => RealmEventsConfigRepresentationFromJSON(jsonValue));
|
||
}
|
||
|
||
/**
|
||
* Get the events provider configuration Returns JSON object with events provider configuration
|
||
*/
|
||
async realmEventsConfigGet(requestParameters: RealmEventsConfigGetRequest): Promise<RealmEventsConfigRepresentation> {
|
||
const response = await this.realmEventsConfigGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
* Update the events provider Change the events provider and/or its configuration
|
||
*/
|
||
async realmEventsConfigPutRaw(requestParameters: RealmEventsConfigPutRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmEventsConfigPut.');
|
||
}
|
||
|
||
if (requestParameters.realmEventsConfigRepresentation === null || requestParameters.realmEventsConfigRepresentation === undefined) {
|
||
throw new runtime.RequiredError('realmEventsConfigRepresentation','Required parameter requestParameters.realmEventsConfigRepresentation was null or undefined when calling realmEventsConfigPut.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'application/json';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/events/config`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'PUT',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: RealmEventsConfigRepresentationToJSON(requestParameters.realmEventsConfigRepresentation),
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Update the events provider Change the events provider and/or its configuration
|
||
*/
|
||
async realmEventsConfigPut(requestParameters: RealmEventsConfigPutRequest): Promise<void> {
|
||
await this.realmEventsConfigPutRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Delete all events
|
||
*/
|
||
async realmEventsDeleteRaw(requestParameters: RealmEventsDeleteRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmEventsDelete.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/events`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'DELETE',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Delete all events
|
||
*/
|
||
async realmEventsDelete(requestParameters: RealmEventsDeleteRequest): Promise<void> {
|
||
await this.realmEventsDeleteRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Get events Returns all events, or filters them based on URL query parameters listed here
|
||
*/
|
||
async realmEventsGetRaw(requestParameters: RealmEventsGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmEventsGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
if (requestParameters.client !== undefined) {
|
||
queryParameters['client'] = requestParameters.client;
|
||
}
|
||
|
||
if (requestParameters.dateFrom !== undefined) {
|
||
queryParameters['dateFrom'] = requestParameters.dateFrom;
|
||
}
|
||
|
||
if (requestParameters.dateTo !== undefined) {
|
||
queryParameters['dateTo'] = requestParameters.dateTo;
|
||
}
|
||
|
||
if (requestParameters.first !== undefined) {
|
||
queryParameters['first'] = requestParameters.first;
|
||
}
|
||
|
||
if (requestParameters.ipAddress !== undefined) {
|
||
queryParameters['ipAddress'] = requestParameters.ipAddress;
|
||
}
|
||
|
||
if (requestParameters.max !== undefined) {
|
||
queryParameters['max'] = requestParameters.max;
|
||
}
|
||
|
||
if (requestParameters.type) {
|
||
queryParameters['type'] = requestParameters.type;
|
||
}
|
||
|
||
if (requestParameters.user !== undefined) {
|
||
queryParameters['user'] = requestParameters.user;
|
||
}
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/events`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse<any>(response);
|
||
}
|
||
|
||
/**
|
||
* Get events Returns all events, or filters them based on URL query parameters listed here
|
||
*/
|
||
async realmEventsGet(requestParameters: RealmEventsGetRequest): Promise<Array<{ [key: string]: object; }>> {
|
||
const response = await this.realmEventsGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
* Get the top-level representation of the realm It will not include nested information like User and Client representations.
|
||
*/
|
||
async realmGetRaw(requestParameters: RealmGetRequest): Promise<runtime.ApiResponse<RealmRepresentation>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse(response, (jsonValue) => RealmRepresentationFromJSON(jsonValue));
|
||
}
|
||
|
||
/**
|
||
* Get the top-level representation of the realm It will not include nested information like User and Client representations.
|
||
*/
|
||
async realmGet(requestParameters: RealmGetRequest): Promise<RealmRepresentation> {
|
||
const response = await this.realmGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmGroupByPathPathGetRaw(requestParameters: RealmGroupByPathPathGetRequest): Promise<runtime.ApiResponse<GroupRepresentation>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmGroupByPathPathGet.');
|
||
}
|
||
|
||
if (requestParameters.path === null || requestParameters.path === undefined) {
|
||
throw new runtime.RequiredError('path','Required parameter requestParameters.path was null or undefined when calling realmGroupByPathPathGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/group-by-path/{path}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"path"}}`, encodeURIComponent(String(requestParameters.path))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse(response, (jsonValue) => GroupRepresentationFromJSON(jsonValue));
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmGroupByPathPathGet(requestParameters: RealmGroupByPathPathGetRequest): Promise<GroupRepresentation> {
|
||
const response = await this.realmGroupByPathPathGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
* Get LDAP supported extensions.
|
||
*/
|
||
async realmLdapServerCapabilitiesPostRaw(requestParameters: RealmLdapServerCapabilitiesPostRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmLdapServerCapabilitiesPost.');
|
||
}
|
||
|
||
if (requestParameters.testLdapConnectionRepresentation === null || requestParameters.testLdapConnectionRepresentation === undefined) {
|
||
throw new runtime.RequiredError('testLdapConnectionRepresentation','Required parameter requestParameters.testLdapConnectionRepresentation was null or undefined when calling realmLdapServerCapabilitiesPost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'application/json';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/ldap-server-capabilities`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: TestLdapConnectionRepresentationToJSON(requestParameters.testLdapConnectionRepresentation),
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Get LDAP supported extensions.
|
||
*/
|
||
async realmLdapServerCapabilitiesPost(requestParameters: RealmLdapServerCapabilitiesPostRequest): Promise<void> {
|
||
await this.realmLdapServerCapabilitiesPostRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationGetRaw(requestParameters: RealmLocalizationGetRequest): Promise<runtime.ApiResponse<Array<{ [key: string]: object; }>>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmLocalizationGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/localization`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse<any>(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationGet(requestParameters: RealmLocalizationGetRequest): Promise<Array<{ [key: string]: object; }>> {
|
||
const response = await this.realmLocalizationGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationLocaleDeleteRaw(requestParameters: RealmLocalizationLocaleDeleteRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmLocalizationLocaleDelete.');
|
||
}
|
||
|
||
if (requestParameters.locale === null || requestParameters.locale === undefined) {
|
||
throw new runtime.RequiredError('locale','Required parameter requestParameters.locale was null or undefined when calling realmLocalizationLocaleDelete.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/localization/{locale}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"locale"}}`, encodeURIComponent(String(requestParameters.locale))),
|
||
method: 'DELETE',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationLocaleDelete(requestParameters: RealmLocalizationLocaleDeleteRequest): Promise<void> {
|
||
await this.realmLocalizationLocaleDeleteRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationLocaleGetRaw(requestParameters: RealmLocalizationLocaleGetRequest): Promise<runtime.ApiResponse<{ [key: string]: object; }>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmLocalizationLocaleGet.');
|
||
}
|
||
|
||
if (requestParameters.locale === null || requestParameters.locale === undefined) {
|
||
throw new runtime.RequiredError('locale','Required parameter requestParameters.locale was null or undefined when calling realmLocalizationLocaleGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/localization/{locale}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"locale"}}`, encodeURIComponent(String(requestParameters.locale))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse<any>(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationLocaleGet(requestParameters: RealmLocalizationLocaleGetRequest): Promise<{ [key: string]: object; }> {
|
||
const response = await this.realmLocalizationLocaleGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationLocaleKeyDeleteRaw(requestParameters: RealmLocalizationLocaleKeyDeleteRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmLocalizationLocaleKeyDelete.');
|
||
}
|
||
|
||
if (requestParameters.locale === null || requestParameters.locale === undefined) {
|
||
throw new runtime.RequiredError('locale','Required parameter requestParameters.locale was null or undefined when calling realmLocalizationLocaleKeyDelete.');
|
||
}
|
||
|
||
if (requestParameters.key === null || requestParameters.key === undefined) {
|
||
throw new runtime.RequiredError('key','Required parameter requestParameters.key was null or undefined when calling realmLocalizationLocaleKeyDelete.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/localization/{locale}/{key}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"locale"}}`, encodeURIComponent(String(requestParameters.locale))).replace(`{${"key"}}`, encodeURIComponent(String(requestParameters.key))),
|
||
method: 'DELETE',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationLocaleKeyDelete(requestParameters: RealmLocalizationLocaleKeyDeleteRequest): Promise<void> {
|
||
await this.realmLocalizationLocaleKeyDeleteRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationLocaleKeyGetRaw(requestParameters: RealmLocalizationLocaleKeyGetRequest): Promise<runtime.ApiResponse<string>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmLocalizationLocaleKeyGet.');
|
||
}
|
||
|
||
if (requestParameters.locale === null || requestParameters.locale === undefined) {
|
||
throw new runtime.RequiredError('locale','Required parameter requestParameters.locale was null or undefined when calling realmLocalizationLocaleKeyGet.');
|
||
}
|
||
|
||
if (requestParameters.key === null || requestParameters.key === undefined) {
|
||
throw new runtime.RequiredError('key','Required parameter requestParameters.key was null or undefined when calling realmLocalizationLocaleKeyGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/localization/{locale}/{key}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"locale"}}`, encodeURIComponent(String(requestParameters.locale))).replace(`{${"key"}}`, encodeURIComponent(String(requestParameters.key))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.TextApiResponse(response) as any;
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationLocaleKeyGet(requestParameters: RealmLocalizationLocaleKeyGetRequest): Promise<string> {
|
||
const response = await this.realmLocalizationLocaleKeyGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationLocaleKeyPutRaw(requestParameters: RealmLocalizationLocaleKeyPutRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmLocalizationLocaleKeyPut.');
|
||
}
|
||
|
||
if (requestParameters.locale === null || requestParameters.locale === undefined) {
|
||
throw new runtime.RequiredError('locale','Required parameter requestParameters.locale was null or undefined when calling realmLocalizationLocaleKeyPut.');
|
||
}
|
||
|
||
if (requestParameters.key === null || requestParameters.key === undefined) {
|
||
throw new runtime.RequiredError('key','Required parameter requestParameters.key was null or undefined when calling realmLocalizationLocaleKeyPut.');
|
||
}
|
||
|
||
if (requestParameters.body === null || requestParameters.body === undefined) {
|
||
throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling realmLocalizationLocaleKeyPut.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'text/plain';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/localization/{locale}/{key}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"locale"}}`, encodeURIComponent(String(requestParameters.locale))).replace(`{${"key"}}`, encodeURIComponent(String(requestParameters.key))),
|
||
method: 'PUT',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: requestParameters.body as any,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationLocaleKeyPut(requestParameters: RealmLocalizationLocaleKeyPutRequest): Promise<void> {
|
||
await this.realmLocalizationLocaleKeyPutRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationLocalePostRaw(requestParameters: RealmLocalizationLocalePostRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmLocalizationLocalePost.');
|
||
}
|
||
|
||
if (requestParameters.locale === null || requestParameters.locale === undefined) {
|
||
throw new runtime.RequiredError('locale','Required parameter requestParameters.locale was null or undefined when calling realmLocalizationLocalePost.');
|
||
}
|
||
|
||
if (requestParameters.requestBody === null || requestParameters.requestBody === undefined) {
|
||
throw new runtime.RequiredError('requestBody','Required parameter requestParameters.requestBody was null or undefined when calling realmLocalizationLocalePost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'application/json';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/localization/{locale}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"locale"}}`, encodeURIComponent(String(requestParameters.locale))),
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: requestParameters.requestBody,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmLocalizationLocalePost(requestParameters: RealmLocalizationLocalePostRequest): Promise<void> {
|
||
await this.realmLocalizationLocalePostRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Removes all user sessions.
|
||
*/
|
||
async realmLogoutAllPostRaw(requestParameters: RealmLogoutAllPostRequest): Promise<runtime.ApiResponse<GlobalRequestResult>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmLogoutAllPost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/logout-all`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse(response, (jsonValue) => GlobalRequestResultFromJSON(jsonValue));
|
||
}
|
||
|
||
/**
|
||
* Removes all user sessions.
|
||
*/
|
||
async realmLogoutAllPost(requestParameters: RealmLogoutAllPostRequest): Promise<GlobalRequestResult> {
|
||
const response = await this.realmLogoutAllPostRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
* Partial export of existing realm into a JSON file.
|
||
*/
|
||
async realmPartialExportPostRaw(requestParameters: RealmPartialExportPostRequest): Promise<runtime.ApiResponse<RealmRepresentation>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmPartialExportPost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
if (requestParameters.exportClients !== undefined) {
|
||
queryParameters['exportClients'] = requestParameters.exportClients;
|
||
}
|
||
|
||
if (requestParameters.exportGroupsAndRoles !== undefined) {
|
||
queryParameters['exportGroupsAndRoles'] = requestParameters.exportGroupsAndRoles;
|
||
}
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/partial-export`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse(response, (jsonValue) => RealmRepresentationFromJSON(jsonValue));
|
||
}
|
||
|
||
/**
|
||
* Partial export of existing realm into a JSON file.
|
||
*/
|
||
async realmPartialExportPost(requestParameters: RealmPartialExportPostRequest): Promise<RealmRepresentation> {
|
||
const response = await this.realmPartialExportPostRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
* Partial import from a JSON file to an existing realm.
|
||
*/
|
||
async realmPartialImportPostRaw(requestParameters: RealmPartialImportPostRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmPartialImportPost.');
|
||
}
|
||
|
||
if (requestParameters.partialImportRepresentation === null || requestParameters.partialImportRepresentation === undefined) {
|
||
throw new runtime.RequiredError('partialImportRepresentation','Required parameter requestParameters.partialImportRepresentation was null or undefined when calling realmPartialImportPost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'application/json';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/partialImport`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: PartialImportRepresentationToJSON(requestParameters.partialImportRepresentation),
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Partial import from a JSON file to an existing realm.
|
||
*/
|
||
async realmPartialImportPost(requestParameters: RealmPartialImportPostRequest): Promise<void> {
|
||
await this.realmPartialImportPostRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Push the realm’s revocation policy to any client that has an admin url associated with it.
|
||
*/
|
||
async realmPushRevocationPostRaw(requestParameters: RealmPushRevocationPostRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmPushRevocationPost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/push-revocation`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Push the realm’s revocation policy to any client that has an admin url associated with it.
|
||
*/
|
||
async realmPushRevocationPost(requestParameters: RealmPushRevocationPostRequest): Promise<void> {
|
||
await this.realmPushRevocationPostRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Update the top-level information of the realm Any user, roles or client information in the representation will be ignored.
|
||
*/
|
||
async realmPutRaw(requestParameters: RealmPutRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmPut.');
|
||
}
|
||
|
||
if (requestParameters.realmRepresentation === null || requestParameters.realmRepresentation === undefined) {
|
||
throw new runtime.RequiredError('realmRepresentation','Required parameter requestParameters.realmRepresentation was null or undefined when calling realmPut.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'application/json';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'PUT',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: RealmRepresentationToJSON(requestParameters.realmRepresentation),
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Update the top-level information of the realm Any user, roles or client information in the representation will be ignored.
|
||
*/
|
||
async realmPut(requestParameters: RealmPutRequest): Promise<void> {
|
||
await this.realmPutRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Remove a specific user session.
|
||
*/
|
||
async realmSessionsSessionDeleteRaw(requestParameters: RealmSessionsSessionDeleteRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmSessionsSessionDelete.');
|
||
}
|
||
|
||
if (requestParameters.session === null || requestParameters.session === undefined) {
|
||
throw new runtime.RequiredError('session','Required parameter requestParameters.session was null or undefined when calling realmSessionsSessionDelete.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/sessions/{session}`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))).replace(`{${"session"}}`, encodeURIComponent(String(requestParameters.session))),
|
||
method: 'DELETE',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Remove a specific user session.
|
||
*/
|
||
async realmSessionsSessionDelete(requestParameters: RealmSessionsSessionDeleteRequest): Promise<void> {
|
||
await this.realmSessionsSessionDeleteRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
* Test LDAP connection
|
||
*/
|
||
async realmTestLDAPConnectionPostRaw(requestParameters: RealmTestLDAPConnectionPostRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmTestLDAPConnectionPost.');
|
||
}
|
||
|
||
if (requestParameters.testLdapConnectionRepresentation === null || requestParameters.testLdapConnectionRepresentation === undefined) {
|
||
throw new runtime.RequiredError('testLdapConnectionRepresentation','Required parameter requestParameters.testLdapConnectionRepresentation was null or undefined when calling realmTestLDAPConnectionPost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'application/json';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/testLDAPConnection`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: TestLdapConnectionRepresentationToJSON(requestParameters.testLdapConnectionRepresentation),
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Test LDAP connection
|
||
*/
|
||
async realmTestLDAPConnectionPost(requestParameters: RealmTestLDAPConnectionPostRequest): Promise<void> {
|
||
await this.realmTestLDAPConnectionPostRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmTestSMTPConnectionPostRaw(requestParameters: RealmTestSMTPConnectionPostRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmTestSMTPConnectionPost.');
|
||
}
|
||
|
||
if (requestParameters.requestBody === null || requestParameters.requestBody === undefined) {
|
||
throw new runtime.RequiredError('requestBody','Required parameter requestParameters.requestBody was null or undefined when calling realmTestSMTPConnectionPost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'application/json';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/testSMTPConnection`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: requestParameters.requestBody,
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmTestSMTPConnectionPost(requestParameters: RealmTestSMTPConnectionPostRequest): Promise<void> {
|
||
await this.realmTestSMTPConnectionPostRaw(requestParameters);
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmUsersManagementPermissionsGetRaw(requestParameters: RealmUsersManagementPermissionsGetRequest): Promise<runtime.ApiResponse<ManagementPermissionReference>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmUsersManagementPermissionsGet.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/users-management-permissions`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'GET',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
});
|
||
|
||
return new runtime.JSONApiResponse(response, (jsonValue) => ManagementPermissionReferenceFromJSON(jsonValue));
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmUsersManagementPermissionsGet(requestParameters: RealmUsersManagementPermissionsGetRequest): Promise<ManagementPermissionReference> {
|
||
const response = await this.realmUsersManagementPermissionsGetRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmUsersManagementPermissionsPutRaw(requestParameters: RealmUsersManagementPermissionsPutRequest): Promise<runtime.ApiResponse<ManagementPermissionReference>> {
|
||
if (requestParameters.realm === null || requestParameters.realm === undefined) {
|
||
throw new runtime.RequiredError('realm','Required parameter requestParameters.realm was null or undefined when calling realmUsersManagementPermissionsPut.');
|
||
}
|
||
|
||
if (requestParameters.managementPermissionReference === null || requestParameters.managementPermissionReference === undefined) {
|
||
throw new runtime.RequiredError('managementPermissionReference','Required parameter requestParameters.managementPermissionReference was null or undefined when calling realmUsersManagementPermissionsPut.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'application/json';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/{realm}/users-management-permissions`.replace(`{${"realm"}}`, encodeURIComponent(String(requestParameters.realm))),
|
||
method: 'PUT',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: ManagementPermissionReferenceToJSON(requestParameters.managementPermissionReference),
|
||
});
|
||
|
||
return new runtime.JSONApiResponse(response, (jsonValue) => ManagementPermissionReferenceFromJSON(jsonValue));
|
||
}
|
||
|
||
/**
|
||
*/
|
||
async realmUsersManagementPermissionsPut(requestParameters: RealmUsersManagementPermissionsPutRequest): Promise<ManagementPermissionReference> {
|
||
const response = await this.realmUsersManagementPermissionsPutRaw(requestParameters);
|
||
return await response.value();
|
||
}
|
||
|
||
/**
|
||
* Import a realm Imports a realm from a full representation of that realm.
|
||
*/
|
||
async rootPostRaw(requestParameters: RootPostRequest): Promise<runtime.ApiResponse<void>> {
|
||
if (requestParameters.realmRepresentation === null || requestParameters.realmRepresentation === undefined) {
|
||
throw new runtime.RequiredError('realmRepresentation','Required parameter requestParameters.realmRepresentation was null or undefined when calling rootPost.');
|
||
}
|
||
|
||
const queryParameters: runtime.HTTPQuery = {};
|
||
|
||
const headerParameters: runtime.HTTPHeaders = {};
|
||
|
||
headerParameters['Content-Type'] = 'application/json';
|
||
|
||
if (this.configuration && this.configuration.accessToken) {
|
||
const token = this.configuration.accessToken;
|
||
const tokenString = typeof token === 'function' ? token("access_token", []) : token;
|
||
|
||
if (tokenString) {
|
||
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
||
}
|
||
}
|
||
const response = await this.request({
|
||
path: `/`,
|
||
method: 'POST',
|
||
headers: headerParameters,
|
||
query: queryParameters,
|
||
body: RealmRepresentationToJSON(requestParameters.realmRepresentation),
|
||
});
|
||
|
||
return new runtime.VoidApiResponse(response);
|
||
}
|
||
|
||
/**
|
||
* Import a realm Imports a realm from a full representation of that realm.
|
||
*/
|
||
async rootPost(requestParameters: RootPostRequest): Promise<void> {
|
||
await this.rootPostRaw(requestParameters);
|
||
}
|
||
|
||
}
|