Class AdminApiMock

java.lang.Object
org.bremersee.keycloak.api.webflux.AdminApiMock
All Implemented Interfaces:
AdminApi

@Validated public class AdminApiMock extends Object implements AdminApi
The admin api mock.
Author:
Christian Bremer
  • Constructor Details

    • AdminApiMock

      public AdminApiMock()
      Instantiates a new admin api mock.
  • Method Details

    • adminRealmsGet

      public reactor.core.publisher.Flux<RealmRepresentation> adminRealmsGet(@Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms : Get accessible realms Returns a list of accessible realms. The list is filtered based on what realms the caller is allowed to view.
      Specified by:
      adminRealmsGet in interface AdminApi
      Parameters:
      briefRepresentation - (optional, default to false)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsPost

      public reactor.core.publisher.Mono<Void> adminRealmsPost(@Valid @Valid reactor.core.publisher.Mono<org.springframework.core.io.Resource> body)
      Description copied from interface: AdminApi
      POST /admin/realms : Import a realm. Imports a realm from a full representation of that realm. Realm name must be unique.
      Specified by:
      adminRealmsPost in interface AdminApi
      Parameters:
      body - (optional)
      Returns:
      Created (status code 201) or Bad Request (status code 400) or Forbidden (status code 403) or Conflict (status code 409) or Internal Server Error (status code 500)
    • adminRealmsRealmAdminEventsDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAdminEventsDelete(String realm)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/admin-events : Delete all admin events
      Specified by:
      adminRealmsRealmAdminEventsDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403)
    • adminRealmsRealmAdminEventsGet

      public reactor.core.publisher.Flux<AdminEventRepresentation> adminRealmsRealmAdminEventsGet(String realm, @Valid @Nullable @Valid String authClient, @Valid @Nullable @Valid String authIpAddress, @Valid @Nullable @Valid String authRealm, @Valid @Nullable @Valid String authUser, @Valid @Nullable @Valid String dateFrom, @Valid @Nullable @Valid String dateTo, @Valid @Nullable @Valid String direction, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid List<String> operationTypes, @Valid @Nullable @Valid String resourcePath, @Valid @Nullable @Valid List<String> resourceTypes)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/admin-events : Get admin events Returns all admin events, or filters events based on URL query parameters listed here
      Specified by:
      adminRealmsRealmAdminEventsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      authClient - (optional)
      authIpAddress - (optional)
      authRealm - (optional)
      authUser - user id (optional)
      dateFrom - From (inclusive) date (yyyy-MM-dd) or time in Epoch timestamp millis (number of milliseconds since January 1, 1970, 00:00:00 GMT) (optional)
      dateTo - To (inclusive) date (yyyy-MM-dd) or time in Epoch timestamp millis (number of milliseconds since January 1, 1970, 00:00:00 GMT) (optional)
      direction - The direction to sort events by (asc or desc) (optional)
      first - (optional)
      max - Maximum results size (defaults to 100) (optional)
      operationTypes - (optional)
      resourcePath - (optional)
      resourceTypes - (optional)
      Returns:
      OK (status code 200) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmAttackDetectionBruteForceUsersDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAttackDetectionBruteForceUsersDelete(String realm)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/attack-detection/brute-force/users : Clear any user login failures for all users This can release temporary disabled users
      Specified by:
      adminRealmsRealmAttackDetectionBruteForceUsersDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAttackDetectionBruteForceUsersUserIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAttackDetectionBruteForceUsersUserIdDelete(String realm, String userId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/attack-detection/brute-force/users/{userId} : Clear any user login failures for the user This can release temporary disabled user
      Specified by:
      adminRealmsRealmAttackDetectionBruteForceUsersUserIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAttackDetectionBruteForceUsersUserIdGet

      public reactor.core.publisher.Mono<Map<String,Object>> adminRealmsRealmAttackDetectionBruteForceUsersUserIdGet(String realm, String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/attack-detection/brute-force/users/{userId} : Get status of a username in brute force detection
      Specified by:
      adminRealmsRealmAttackDetectionBruteForceUsersUserIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationAuthenticatorProvidersGet

      public reactor.core.publisher.Flux<Map<String,Object>> adminRealmsRealmAuthenticationAuthenticatorProvidersGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/authenticator-providers : Get authenticator providers Returns a stream of authenticator providers.
      Specified by:
      adminRealmsRealmAuthenticationAuthenticatorProvidersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationClientAuthenticatorProvidersGet

      public reactor.core.publisher.Flux<Map<String,Object>> adminRealmsRealmAuthenticationClientAuthenticatorProvidersGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/client-authenticator-providers : Get client authenticator providers Returns a stream of client authenticator providers.
      Specified by:
      adminRealmsRealmAuthenticationClientAuthenticatorProvidersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationConfigDescriptionProviderIdGet

      public reactor.core.publisher.Mono<AuthenticatorConfigInfoRepresentation> adminRealmsRealmAuthenticationConfigDescriptionProviderIdGet(String realm, String providerId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/config-description/{providerId} : Get authenticator provider's configuration description
      Specified by:
      adminRealmsRealmAuthenticationConfigDescriptionProviderIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      providerId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationConfigIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationConfigIdDelete(String realm, String id)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/authentication/config/{id} : Delete authenticator configuration
      Specified by:
      adminRealmsRealmAuthenticationConfigIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - Configuration id (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationConfigIdGet

      public reactor.core.publisher.Mono<AuthenticatorConfigRepresentation> adminRealmsRealmAuthenticationConfigIdGet(String realm, String id)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/config/{id} : Get authenticator configuration
      Specified by:
      adminRealmsRealmAuthenticationConfigIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - Configuration id (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationConfigIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationConfigIdPut(String realm, String id, @Valid @Valid reactor.core.publisher.Mono<AuthenticatorConfigRepresentation> authenticatorConfigRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/authentication/config/{id} : Update authenticator configuration
      Specified by:
      adminRealmsRealmAuthenticationConfigIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - Configuration id (required)
      authenticatorConfigRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationConfigPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationConfigPost(String realm, @Valid @Valid reactor.core.publisher.Mono<AuthenticatorConfigRepresentation> authenticatorConfigRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/authentication/config : Create new authenticator configuration
      Specified by:
      adminRealmsRealmAuthenticationConfigPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      authenticatorConfigRepresentation - (optional)
      Returns:
      Created (status code 201) or Conflict (status code 409)
    • adminRealmsRealmAuthenticationExecutionsExecutionIdConfigIdGet

      public reactor.core.publisher.Mono<AuthenticatorConfigRepresentation> adminRealmsRealmAuthenticationExecutionsExecutionIdConfigIdGet(String realm, String executionId, String id)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/executions/{executionId}/config/{id} : Get execution's configuration
      Specified by:
      adminRealmsRealmAuthenticationExecutionsExecutionIdConfigIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      executionId - Execution id (required)
      id - Configuration id (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationExecutionsExecutionIdConfigPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationExecutionsExecutionIdConfigPost(String realm, String executionId, @Valid @Valid reactor.core.publisher.Mono<AuthenticatorConfigRepresentation> authenticatorConfigRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/authentication/executions/{executionId}/config : Update execution with new configuration
      Specified by:
      adminRealmsRealmAuthenticationExecutionsExecutionIdConfigPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      executionId - Execution id (required)
      authenticatorConfigRepresentation - (optional)
      Returns:
      Created (status code 201) or Conflict (status code 409)
    • adminRealmsRealmAuthenticationExecutionsExecutionIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationExecutionsExecutionIdDelete(String realm, String executionId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/authentication/executions/{executionId} : Delete execution
      Specified by:
      adminRealmsRealmAuthenticationExecutionsExecutionIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      executionId - Execution id (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationExecutionsExecutionIdGet

      public reactor.core.publisher.Mono<AuthenticationExecutionRepresentation> adminRealmsRealmAuthenticationExecutionsExecutionIdGet(String realm, String executionId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/executions/{executionId} : Get Single Execution
      Specified by:
      adminRealmsRealmAuthenticationExecutionsExecutionIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      executionId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationExecutionsExecutionIdLowerPriorityPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationExecutionsExecutionIdLowerPriorityPost(String realm, String executionId)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/authentication/executions/{executionId}/lower-priority : Lower execution's priority
      Specified by:
      adminRealmsRealmAuthenticationExecutionsExecutionIdLowerPriorityPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      executionId - Execution id (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationExecutionsExecutionIdRaisePriorityPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationExecutionsExecutionIdRaisePriorityPost(String realm, String executionId)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/authentication/executions/{executionId}/raise-priority : Raise execution's priority
      Specified by:
      adminRealmsRealmAuthenticationExecutionsExecutionIdRaisePriorityPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      executionId - Execution id (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationExecutionsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationExecutionsPost(String realm, @Valid @Valid reactor.core.publisher.Mono<AuthenticationExecutionRepresentation> authenticationExecutionRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/authentication/executions : Add new authentication execution
      Specified by:
      adminRealmsRealmAuthenticationExecutionsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      authenticationExecutionRepresentation - (optional)
      Returns:
      Created (status code 201)
    • adminRealmsRealmAuthenticationFlowsFlowAliasCopyPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationFlowsFlowAliasCopyPost(String realm, String flowAlias, @Valid @Valid reactor.core.publisher.Mono<Map<String,String>> requestBody)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/authentication/flows/{flowAlias}/copy : Copy existing authentication flow under a new name The new name is given as 'newName' attribute of the passed JSON object
      Specified by:
      adminRealmsRealmAuthenticationFlowsFlowAliasCopyPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      flowAlias - name of the existing authentication flow (required)
      requestBody - (optional)
      Returns:
      Created (status code 201) or Conflict (status code 409)
    • adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsExecutionPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsExecutionPost(String realm, String flowAlias, @Valid @Valid reactor.core.publisher.Mono<Map<String,Object>> requestBody)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/authentication/flows/{flowAlias}/executions/execution : Add new authentication execution to a flow
      Specified by:
      adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsExecutionPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      flowAlias - Alias of parent flow (required)
      requestBody - (optional)
      Returns:
      Created (status code 201)
    • adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsFlowPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsFlowPost(String realm, String flowAlias, @Valid @Valid reactor.core.publisher.Mono<Map<String,Object>> requestBody)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/authentication/flows/{flowAlias}/executions/flow : Add new flow with new execution to existing flow
      Specified by:
      adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsFlowPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      flowAlias - Alias of parent authentication flow (required)
      requestBody - (optional)
      Returns:
      Created (status code 201) or Conflict (status code 409)
    • adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsGet

      public reactor.core.publisher.Flux<AuthenticationExecutionInfoRepresentation> adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsGet(String realm, String flowAlias)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/flows/{flowAlias}/executions : Get authentication executions for a flow
      Specified by:
      adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      flowAlias - Flow alias (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsPut(String realm, String flowAlias, @Valid @Valid reactor.core.publisher.Mono<AuthenticationExecutionInfoRepresentation> authenticationExecutionInfoRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/authentication/flows/{flowAlias}/executions : Update authentication executions of a Flow
      Specified by:
      adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      flowAlias - Flow alias (required)
      authenticationExecutionInfoRepresentation - (optional)
      Returns:
      No Content (status code 204) or Conflict (status code 409)
    • adminRealmsRealmAuthenticationFlowsGet

      public reactor.core.publisher.Flux<AuthenticationFlowRepresentation> adminRealmsRealmAuthenticationFlowsGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/flows : Get authentication flows Returns a stream of authentication flows.
      Specified by:
      adminRealmsRealmAuthenticationFlowsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationFlowsIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationFlowsIdDelete(String realm, String id)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/authentication/flows/{id} : Delete an authentication flow
      Specified by:
      adminRealmsRealmAuthenticationFlowsIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - Flow id (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationFlowsIdGet

      public reactor.core.publisher.Mono<AuthenticationFlowRepresentation> adminRealmsRealmAuthenticationFlowsIdGet(String realm, String id)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/flows/{id} : Get authentication flow for id
      Specified by:
      adminRealmsRealmAuthenticationFlowsIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - Flow id (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationFlowsIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationFlowsIdPut(String realm, String id, @Valid @Valid reactor.core.publisher.Mono<AuthenticationFlowRepresentation> authenticationFlowRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/authentication/flows/{id} : Update an authentication flow
      Specified by:
      adminRealmsRealmAuthenticationFlowsIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - (required)
      authenticationFlowRepresentation - (optional)
      Returns:
      No Content (status code 204) or Conflict (status code 409)
    • adminRealmsRealmAuthenticationFlowsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationFlowsPost(String realm, @Valid @Valid reactor.core.publisher.Mono<AuthenticationFlowRepresentation> authenticationFlowRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/authentication/flows : Create a new authentication flow
      Specified by:
      adminRealmsRealmAuthenticationFlowsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      authenticationFlowRepresentation - (optional)
      Returns:
      Created (status code 201) or Conflict (status code 409)
    • adminRealmsRealmAuthenticationFormActionProvidersGet

      public reactor.core.publisher.Flux<Map<String,Object>> adminRealmsRealmAuthenticationFormActionProvidersGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/form-action-providers : Get form action providers Returns a stream of form action providers.
      Specified by:
      adminRealmsRealmAuthenticationFormActionProvidersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationFormProvidersGet

      public reactor.core.publisher.Flux<Map<String,Object>> adminRealmsRealmAuthenticationFormProvidersGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/form-providers : Get form providers Returns a stream of form providers.
      Specified by:
      adminRealmsRealmAuthenticationFormProvidersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationPerClientConfigDescriptionGet

      public reactor.core.publisher.Mono<Map<String,List<ConfigPropertyRepresentation>>> adminRealmsRealmAuthenticationPerClientConfigDescriptionGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/per-client-config-description : Get configuration descriptions for all clients
      Specified by:
      adminRealmsRealmAuthenticationPerClientConfigDescriptionGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationRegisterRequiredActionPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationRegisterRequiredActionPost(String realm, @Valid @Valid reactor.core.publisher.Mono<Map<String,String>> requestBody)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/authentication/register-required-action : Register a new required actions
      Specified by:
      adminRealmsRealmAuthenticationRegisterRequiredActionPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      requestBody - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationRequiredActionsAliasConfigDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasConfigDelete(String realm, String alias)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/authentication/required-actions/{alias}/config : Delete RequiredAction configuration
      Specified by:
      adminRealmsRealmAuthenticationRequiredActionsAliasConfigDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - Alias of required action (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationRequiredActionsAliasConfigDescriptionGet

      public reactor.core.publisher.Mono<RequiredActionConfigInfoRepresentation> adminRealmsRealmAuthenticationRequiredActionsAliasConfigDescriptionGet(String realm, String alias)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/required-actions/{alias}/config-description : Get RequiredAction provider configuration description
      Specified by:
      adminRealmsRealmAuthenticationRequiredActionsAliasConfigDescriptionGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - Alias of required action (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationRequiredActionsAliasConfigGet

      public reactor.core.publisher.Mono<RequiredActionConfigRepresentation> adminRealmsRealmAuthenticationRequiredActionsAliasConfigGet(String realm, String alias)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/required-actions/{alias}/config : Get RequiredAction configuration
      Specified by:
      adminRealmsRealmAuthenticationRequiredActionsAliasConfigGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - Alias of required action (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationRequiredActionsAliasConfigPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasConfigPut(String realm, String alias, @Valid @Valid reactor.core.publisher.Mono<RequiredActionConfigRepresentation> requiredActionConfigRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/authentication/required-actions/{alias}/config : Update RequiredAction configuration
      Specified by:
      adminRealmsRealmAuthenticationRequiredActionsAliasConfigPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - Alias of required action (required)
      requiredActionConfigRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationRequiredActionsAliasDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasDelete(String realm, String alias)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/authentication/required-actions/{alias} : Delete required action
      Specified by:
      adminRealmsRealmAuthenticationRequiredActionsAliasDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - Alias of required action (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationRequiredActionsAliasGet

      public reactor.core.publisher.Mono<RequiredActionProviderRepresentation> adminRealmsRealmAuthenticationRequiredActionsAliasGet(String realm, String alias)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/required-actions/{alias} : Get required action for alias
      Specified by:
      adminRealmsRealmAuthenticationRequiredActionsAliasGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - Alias of required action (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationRequiredActionsAliasLowerPriorityPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasLowerPriorityPost(String realm, String alias)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/authentication/required-actions/{alias}/lower-priority : Lower required action's priority
      Specified by:
      adminRealmsRealmAuthenticationRequiredActionsAliasLowerPriorityPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - Alias of required action (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationRequiredActionsAliasPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasPut(String realm, String alias, @Valid @Valid reactor.core.publisher.Mono<RequiredActionProviderRepresentation> requiredActionProviderRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/authentication/required-actions/{alias} : Update required action
      Specified by:
      adminRealmsRealmAuthenticationRequiredActionsAliasPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - Alias of required action (required)
      requiredActionProviderRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationRequiredActionsAliasRaisePriorityPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasRaisePriorityPost(String realm, String alias)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/authentication/required-actions/{alias}/raise-priority : Raise required action's priority
      Specified by:
      adminRealmsRealmAuthenticationRequiredActionsAliasRaisePriorityPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - Alias of required action (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmAuthenticationRequiredActionsGet

      public reactor.core.publisher.Flux<RequiredActionProviderRepresentation> adminRealmsRealmAuthenticationRequiredActionsGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/required-actions : Get required actions Returns a stream of required actions.
      Specified by:
      adminRealmsRealmAuthenticationRequiredActionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmAuthenticationUnregisteredRequiredActionsGet

      public reactor.core.publisher.Flux<Map<String,String>> adminRealmsRealmAuthenticationUnregisteredRequiredActionsGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/authentication/unregistered-required-actions : Get unregistered required actions Returns a stream of unregistered required actions.
      Specified by:
      adminRealmsRealmAuthenticationUnregisteredRequiredActionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientDescriptionConverterPost

      public reactor.core.publisher.Mono<ClientRepresentation> adminRealmsRealmClientDescriptionConverterPost(String realm, @Valid @Valid reactor.core.publisher.Mono<String> body)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/client-description-converter : Base path for importing clients under this realm.
      Specified by:
      adminRealmsRealmClientDescriptionConverterPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      body - (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientPoliciesPoliciesGet

      public reactor.core.publisher.Mono<ClientPoliciesRepresentation> adminRealmsRealmClientPoliciesPoliciesGet(String realm, @Valid @Nullable @Valid Boolean includeGlobalPolicies)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-policies/policies
      Specified by:
      adminRealmsRealmClientPoliciesPoliciesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      includeGlobalPolicies - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientPoliciesPoliciesPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientPoliciesPoliciesPut(String realm, @Valid @Valid reactor.core.publisher.Mono<ClientPoliciesRepresentation> clientPoliciesRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/client-policies/policies
      Specified by:
      adminRealmsRealmClientPoliciesPoliciesPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientPoliciesRepresentation - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientPoliciesProfilesGet

      public reactor.core.publisher.Mono<ClientProfilesRepresentation> adminRealmsRealmClientPoliciesProfilesGet(String realm, @Valid @Nullable @Valid Boolean includeGlobalProfiles)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-policies/profiles
      Specified by:
      adminRealmsRealmClientPoliciesProfilesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      includeGlobalProfiles - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientPoliciesProfilesPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientPoliciesProfilesPut(String realm, @Valid @Valid reactor.core.publisher.Mono<ClientProfilesRepresentation> clientProfilesRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/client-policies/profiles
      Specified by:
      adminRealmsRealmClientPoliciesProfilesPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientProfilesRepresentation - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientRegistrationPolicyProvidersGet

      public reactor.core.publisher.Flux<ComponentTypeRepresentation> adminRealmsRealmClientRegistrationPolicyProvidersGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-registration-policy/providers : Base path for retrieve providers with the configProperties properly filled
      Specified by:
      adminRealmsRealmClientRegistrationPolicyProvidersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientScopesClientScopeIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientScopesClientScopeIdDelete(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/client-scopes/{client-scope-id} : Delete the client scope
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Internal Server Error (status code 500)
    • adminRealmsRealmClientScopesClientScopeIdGet

      public reactor.core.publisher.Mono<ClientScopeRepresentation> adminRealmsRealmClientScopesClientScopeIdGet(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-scopes/{client-scope-id} : Get representation of the client scope
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPost(String realm, String clientScopeId, @Valid @Valid reactor.core.publisher.Flux<ProtocolMapperRepresentation> protocolMapperRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/add-models : Create multiple mappers
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      protocolMapperRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGet

      public reactor.core.publisher.Flux<ProtocolMapperRepresentation> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGet(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/models : Get mappers
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDelete(String realm, String clientScopeId, String id)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/models/{id} : Delete the mapper
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      id - Mapper id (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGet

      public reactor.core.publisher.Mono<ProtocolMapperRepresentation> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGet(String realm, String clientScopeId, String id)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/models/{id} : Get mapper by id
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      id - Mapper id (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPut(String realm, String clientScopeId, String id, @Valid @Valid reactor.core.publisher.Mono<ProtocolMapperRepresentation> protocolMapperRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/models/{id} : Update the mapper
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      id - Mapper id (required)
      protocolMapperRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPost(String realm, String clientScopeId, @Valid @Valid reactor.core.publisher.Mono<ProtocolMapperRepresentation> protocolMapperRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/models : Create a mapper
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      protocolMapperRepresentation - (optional)
      Returns:
      Created (status code 201) or Conflict (status code 409)
    • adminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGet

      public reactor.core.publisher.Flux<ProtocolMapperRepresentation> adminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGet(String realm, String clientScopeId, String protocol)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-scopes/{client-scope-id}/protocol-mappers/protocol/{protocol} : Get mappers by name for a specific protocol
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      protocol - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientScopesClientScopeIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientScopesClientScopeIdPut(String realm, String clientScopeId, @Valid @Valid reactor.core.publisher.Mono<ClientScopeRepresentation> clientScopeRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/client-scopes/{client-scope-id} : Update the client scope
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      clientScopeRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Conflict (status code 409)
    • adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientAvailableGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientAvailableGet(String realm, String clientScopeId, String client)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-scopes/{client-scope-id}/scope-mappings/clients/{client}/available : The available client-level roles Returns the roles for the client that can be associated with the client's scope
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      client - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientCompositeGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientCompositeGet(String realm, String clientScopeId, String client, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-scopes/{client-scope-id}/scope-mappings/clients/{client}/composite : Get effective client roles Returns the roles for the client that are associated with the client's scope.
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientCompositeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      client - (required)
      briefRepresentation - if false, return roles with their attributes (optional, default to true)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientDelete(String realm, String clientScopeId, String client, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/client-scopes/{client-scope-id}/scope-mappings/clients/{client} : Remove client-level roles from the client's scope.
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      client - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientGet(String realm, String clientScopeId, String client)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-scopes/{client-scope-id}/scope-mappings/clients/{client} : Get the roles associated with a client's scope Returns roles for the client.
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      client - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientPost(String realm, String clientScopeId, String client, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/client-scopes/{client-scope-id}/scope-mappings/clients/{client} : Add client-level roles to the client's scope
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      client - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientScopesClientScopeIdScopeMappingsGet

      public reactor.core.publisher.Mono<MappingsRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsGet(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-scopes/{client-scope-id}/scope-mappings : Get all scope mappings for the client
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdScopeMappingsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmAvailableGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmAvailableGet(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-scopes/{client-scope-id}/scope-mappings/realm/available : Get realm-level roles that are available to attach to this client's scope
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmCompositeGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmCompositeGet(String realm, String clientScopeId, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-scopes/{client-scope-id}/scope-mappings/realm/composite : Get effective realm-level roles associated with the client’s scope What this does is recurse any composite roles associated with the client’s scope and adds the roles to this lists. The method is really to show a comprehensive total view of realm-level roles associated with the client.
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmCompositeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      briefRepresentation - if false, return roles with their attributes (optional, default to true)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmDelete(String realm, String clientScopeId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/client-scopes/{client-scope-id}/scope-mappings/realm : Remove a set of realm-level roles from the client's scope
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmGet(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-scopes/{client-scope-id}/scope-mappings/realm : Get realm-level roles associated with the client's scope
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmPost(String realm, String clientScopeId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/client-scopes/{client-scope-id}/scope-mappings/realm : Add a set of realm-level roles to the client's scope
      Specified by:
      adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientScopesGet

      public reactor.core.publisher.Flux<ClientScopeRepresentation> adminRealmsRealmClientScopesGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-scopes : Get client scopes belonging to the realm Returns a list of client scopes belonging to the realm
      Specified by:
      adminRealmsRealmClientScopesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmClientScopesPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientScopesPost(String realm, @Valid @Valid reactor.core.publisher.Mono<ClientScopeRepresentation> clientScopeRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/client-scopes : Create a new client scope Client Scope’s name must be unique!
      Specified by:
      adminRealmsRealmClientScopesPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeRepresentation - (optional)
      Returns:
      Created (status code 201) or Forbidden (status code 403) or Conflict (status code 409)
    • adminRealmsRealmClientSessionStatsGet

      public reactor.core.publisher.Flux<Map<String,String>> adminRealmsRealmClientSessionStatsGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-session-stats : Get client session stats Returns a JSON map. The key is the client id, the value is the number of sessions that currently are active with that client. Only clients that actually have a session associated with them will be in this map.
      Specified by:
      adminRealmsRealmClientSessionStatsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmClientTemplatesClientScopeIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdDelete(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/client-templates/{client-scope-id} : Delete the client scope
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Internal Server Error (status code 500)
    • adminRealmsRealmClientTemplatesClientScopeIdGet

      public reactor.core.publisher.Mono<ClientScopeRepresentation> adminRealmsRealmClientTemplatesClientScopeIdGet(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-templates/{client-scope-id} : Get representation of the client scope
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPost(String realm, String clientScopeId, @Valid @Valid reactor.core.publisher.Flux<ProtocolMapperRepresentation> protocolMapperRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/add-models : Create multiple mappers
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      protocolMapperRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGet

      public reactor.core.publisher.Flux<ProtocolMapperRepresentation> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGet(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/models : Get mappers
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDelete(String realm, String clientScopeId, String id)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/models/{id} : Delete the mapper
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      id - Mapper id (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGet

      public reactor.core.publisher.Mono<ProtocolMapperRepresentation> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGet(String realm, String clientScopeId, String id)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/models/{id} : Get mapper by id
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      id - Mapper id (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPut(String realm, String clientScopeId, String id, @Valid @Valid reactor.core.publisher.Mono<ProtocolMapperRepresentation> protocolMapperRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/models/{id} : Update the mapper
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      id - Mapper id (required)
      protocolMapperRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPost(String realm, String clientScopeId, @Valid @Valid reactor.core.publisher.Mono<ProtocolMapperRepresentation> protocolMapperRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/models : Create a mapper
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      protocolMapperRepresentation - (optional)
      Returns:
      Created (status code 201) or Conflict (status code 409)
    • adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGet

      public reactor.core.publisher.Flux<ProtocolMapperRepresentation> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGet(String realm, String clientScopeId, String protocol)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-templates/{client-scope-id}/protocol-mappers/protocol/{protocol} : Get mappers by name for a specific protocol
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      protocol - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientTemplatesClientScopeIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdPut(String realm, String clientScopeId, @Valid @Valid reactor.core.publisher.Mono<ClientScopeRepresentation> clientScopeRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/client-templates/{client-scope-id} : Update the client scope
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      clientScopeRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Conflict (status code 409)
    • adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientAvailableGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientAvailableGet(String realm, String clientScopeId, String client)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-templates/{client-scope-id}/scope-mappings/clients/{client}/available : The available client-level roles Returns the roles for the client that can be associated with the client's scope
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      client - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientCompositeGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientCompositeGet(String realm, String clientScopeId, String client, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-templates/{client-scope-id}/scope-mappings/clients/{client}/composite : Get effective client roles Returns the roles for the client that are associated with the client's scope.
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientCompositeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      client - (required)
      briefRepresentation - if false, return roles with their attributes (optional, default to true)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientDelete(String realm, String clientScopeId, String client, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/client-templates/{client-scope-id}/scope-mappings/clients/{client} : Remove client-level roles from the client's scope.
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      client - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientGet(String realm, String clientScopeId, String client)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-templates/{client-scope-id}/scope-mappings/clients/{client} : Get the roles associated with a client's scope Returns roles for the client.
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      client - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientPost(String realm, String clientScopeId, String client, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/client-templates/{client-scope-id}/scope-mappings/clients/{client} : Add client-level roles to the client's scope
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      client - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsGet

      public reactor.core.publisher.Mono<MappingsRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsGet(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-templates/{client-scope-id}/scope-mappings : Get all scope mappings for the client
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmAvailableGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmAvailableGet(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-templates/{client-scope-id}/scope-mappings/realm/available : Get realm-level roles that are available to attach to this client's scope
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmCompositeGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmCompositeGet(String realm, String clientScopeId, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-templates/{client-scope-id}/scope-mappings/realm/composite : Get effective realm-level roles associated with the client’s scope What this does is recurse any composite roles associated with the client’s scope and adds the roles to this lists. The method is really to show a comprehensive total view of realm-level roles associated with the client.
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmCompositeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      briefRepresentation - if false, return roles with their attributes (optional, default to true)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmDelete(String realm, String clientScopeId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/client-templates/{client-scope-id}/scope-mappings/realm : Remove a set of realm-level roles from the client's scope
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmGet(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-templates/{client-scope-id}/scope-mappings/realm : Get realm-level roles associated with the client's scope
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmPost(String realm, String clientScopeId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/client-templates/{client-scope-id}/scope-mappings/realm : Add a set of realm-level roles to the client's scope
      Specified by:
      adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientTemplatesGet

      public reactor.core.publisher.Flux<ClientScopeRepresentation> adminRealmsRealmClientTemplatesGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-templates : Get client scopes belonging to the realm Returns a list of client scopes belonging to the realm
      Specified by:
      adminRealmsRealmClientTemplatesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmClientTemplatesPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientTemplatesPost(String realm, @Valid @Valid reactor.core.publisher.Mono<ClientScopeRepresentation> clientScopeRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/client-templates : Create a new client scope Client Scope’s name must be unique!
      Specified by:
      adminRealmsRealmClientTemplatesPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeRepresentation - (optional)
      Returns:
      Created (status code 201) or Forbidden (status code 403) or Conflict (status code 409)
    • adminRealmsRealmClientTypesGet

      public reactor.core.publisher.Mono<ClientTypesRepresentation> adminRealmsRealmClientTypesGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/client-types : List all client types available in the current realm This endpoint returns a list of both global and realm level client types and the attributes they set
      Specified by:
      adminRealmsRealmClientTypesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientTypesPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientTypesPut(String realm, @Valid @Valid reactor.core.publisher.Mono<ClientTypesRepresentation> clientTypesRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/client-types : Update a client type This endpoint allows you to update a realm level client type
      Specified by:
      adminRealmsRealmClientTypesPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientTypesRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerGet

      public reactor.core.publisher.Mono<ResourceServerRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerImportPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerImportPost(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Mono<ResourceServerRepresentation> resourceServerRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/import
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerImportPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      resourceServerRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionEvaluatePost

      public reactor.core.publisher.Mono<PolicyEvaluationResponse> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionEvaluatePost(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Mono<PolicyEvaluationRequest> policyEvaluationRequest)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/permission/evaluate
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionEvaluatePost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      policyEvaluationRequest - (optional)
      Returns:
      OK (status code 200) or Internal Server Error (status code 500)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionGet

      public reactor.core.publisher.Flux<AbstractPolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionGet(String realm, String clientUuid, @Valid @Nullable @Valid String fields, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String name, @Valid @Nullable @Valid String owner, @Valid @Nullable @Valid Boolean permission, @Valid @Nullable @Valid String policyId, @Valid @Nullable @Valid String resource, @Valid @Nullable @Valid String resourceType, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String type)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/permission
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      fields - (optional)
      first - (optional)
      max - (optional)
      name - (optional)
      owner - (optional)
      permission - (optional)
      policyId - (optional)
      resource - (optional)
      resourceType - (optional)
      scope - (optional)
      type - (optional)
      Returns:
      OK (status code 200) or No Content (status code 204)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionPost(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Mono<String> body)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/permission
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      body - (optional)
      Returns:
      Created (status code 201)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionProvidersGet

      public reactor.core.publisher.Flux<PolicyProviderRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionProvidersGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/permission/providers
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionProvidersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionSearchGet

      public reactor.core.publisher.Mono<AbstractPolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionSearchGet(String realm, String clientUuid, @Valid @Nullable @Valid String fields, @Valid @Nullable @Valid String name)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/permission/search
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionSearchGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      fields - (optional)
      name - (optional)
      Returns:
      OK (status code 200) or No Content (status code 204) or Bad Request (status code 400)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyEvaluatePost

      public reactor.core.publisher.Mono<PolicyEvaluationResponse> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyEvaluatePost(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Mono<PolicyEvaluationRequest> policyEvaluationRequest)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/policy/evaluate
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyEvaluatePost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      policyEvaluationRequest - (optional)
      Returns:
      OK (status code 200) or Internal Server Error (status code 500)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyGet

      public reactor.core.publisher.Flux<AbstractPolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyGet(String realm, String clientUuid, @Valid @Nullable @Valid String fields, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String name, @Valid @Nullable @Valid String owner, @Valid @Nullable @Valid Boolean permission, @Valid @Nullable @Valid String policyId, @Valid @Nullable @Valid String resource, @Valid @Nullable @Valid String resourceType, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String type)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/policy
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      fields - (optional)
      first - (optional)
      max - (optional)
      name - (optional)
      owner - (optional)
      permission - (optional)
      policyId - (optional)
      resource - (optional)
      resourceType - (optional)
      scope - (optional)
      type - (optional)
      Returns:
      OK (status code 200) or No Content (status code 204)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyPost(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Mono<String> body)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/policy
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      body - (optional)
      Returns:
      Created (status code 201)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyProvidersGet

      public reactor.core.publisher.Flux<PolicyProviderRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyProvidersGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/policy/providers
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyProvidersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerPolicySearchGet

      public reactor.core.publisher.Mono<AbstractPolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicySearchGet(String realm, String clientUuid, @Valid @Nullable @Valid String fields, @Valid @Nullable @Valid String name)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/policy/search
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerPolicySearchGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      fields - (optional)
      name - (optional)
      Returns:
      OK (status code 200) or No Content (status code 204) or Bad Request (status code 400)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerPut(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Mono<ResourceServerRepresentation> resourceServerRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      resourceServerRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerResourceGet

      public reactor.core.publisher.Flux<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceGet(String realm, String clientUuid, @Valid @Nullable @Valid String id, @Valid @Nullable @Valid Boolean deep, @Valid @Nullable @Valid Boolean exactName, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Boolean matchingUri, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String name, @Valid @Nullable @Valid String owner, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String type, @Valid @Nullable @Valid String uri)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/resource
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerResourceGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      id - (optional)
      deep - (optional)
      exactName - (optional)
      first - (optional)
      matchingUri - (optional)
      max - (optional)
      name - (optional)
      owner - (optional)
      scope - (optional)
      type - (optional)
      uri - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerResourcePost

      public reactor.core.publisher.Mono<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourcePost(String realm, String clientUuid, @Valid @Nullable @Valid String id, @Valid @Nullable @Valid Boolean deep, @Valid @Nullable @Valid Boolean exactName, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Boolean matchingUri, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String name, @Valid @Nullable @Valid String owner, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String type, @Valid @Nullable @Valid String uri, @Valid @Valid reactor.core.publisher.Mono<ResourceRepresentation> resourceRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/resource
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerResourcePost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      id - (optional)
      deep - (optional)
      exactName - (optional)
      first - (optional)
      matchingUri - (optional)
      max - (optional)
      name - (optional)
      owner - (optional)
      scope - (optional)
      type - (optional)
      uri - (optional)
      resourceRepresentation - (optional)
      Returns:
      Created (status code 201) or Bad Request (status code 400)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdAttributesGet

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdAttributesGet(String realm, String clientUuid, String resourceId, @Valid @Nullable @Valid String id, @Valid @Nullable @Valid Boolean deep, @Valid @Nullable @Valid Boolean exactName, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Boolean matchingUri, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String name, @Valid @Nullable @Valid String owner, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String type, @Valid @Nullable @Valid String uri)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/resource/{resource-id}/attributes
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdAttributesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      resourceId - (required)
      id - (optional)
      deep - (optional)
      exactName - (optional)
      first - (optional)
      matchingUri - (optional)
      max - (optional)
      name - (optional)
      owner - (optional)
      scope - (optional)
      type - (optional)
      uri - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdDelete(String realm, String clientUuid, String resourceId, @Valid @Nullable @Valid String id, @Valid @Nullable @Valid Boolean deep, @Valid @Nullable @Valid Boolean exactName, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Boolean matchingUri, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String name, @Valid @Nullable @Valid String owner, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String type, @Valid @Nullable @Valid String uri)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/resource/{resource-id}
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      resourceId - (required)
      id - (optional)
      deep - (optional)
      exactName - (optional)
      first - (optional)
      matchingUri - (optional)
      max - (optional)
      name - (optional)
      owner - (optional)
      scope - (optional)
      type - (optional)
      uri - (optional)
      Returns:
      No Content (status code 204) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdGet

      public reactor.core.publisher.Mono<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdGet(String realm, String clientUuid, String resourceId, @Valid @Nullable @Valid String id, @Valid @Nullable @Valid Boolean deep, @Valid @Nullable @Valid Boolean exactName, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Boolean matchingUri, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String name, @Valid @Nullable @Valid String owner, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String type, @Valid @Nullable @Valid String uri)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/resource/{resource-id}
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      resourceId - (required)
      id - (optional)
      deep - (optional)
      exactName - (optional)
      first - (optional)
      matchingUri - (optional)
      max - (optional)
      name - (optional)
      owner - (optional)
      scope - (optional)
      type - (optional)
      uri - (optional)
      Returns:
      OK (status code 200) or Not found (status code 404)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdPermissionsGet

      public reactor.core.publisher.Flux<PolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdPermissionsGet(String realm, String clientUuid, String resourceId, @Valid @Nullable @Valid String id, @Valid @Nullable @Valid Boolean deep, @Valid @Nullable @Valid Boolean exactName, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Boolean matchingUri, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String name, @Valid @Nullable @Valid String owner, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String type, @Valid @Nullable @Valid String uri)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/resource/{resource-id}/permissions
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdPermissionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      resourceId - (required)
      id - (optional)
      deep - (optional)
      exactName - (optional)
      first - (optional)
      matchingUri - (optional)
      max - (optional)
      name - (optional)
      owner - (optional)
      scope - (optional)
      type - (optional)
      uri - (optional)
      Returns:
      OK (status code 200) or Not found (status code 404)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdPut(String realm, String clientUuid, String resourceId, @Valid @Nullable @Valid String id, @Valid @Nullable @Valid Boolean deep, @Valid @Nullable @Valid Boolean exactName, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Boolean matchingUri, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String name, @Valid @Nullable @Valid String owner, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String type, @Valid @Nullable @Valid String uri, @Valid @Valid reactor.core.publisher.Mono<ResourceRepresentation> resourceRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/resource/{resource-id}
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      resourceId - (required)
      id - (optional)
      deep - (optional)
      exactName - (optional)
      first - (optional)
      matchingUri - (optional)
      max - (optional)
      name - (optional)
      owner - (optional)
      scope - (optional)
      type - (optional)
      uri - (optional)
      resourceRepresentation - (optional)
      Returns:
      No Content (status code 204) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdScopesGet

      public reactor.core.publisher.Flux<ScopeRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdScopesGet(String realm, String clientUuid, String resourceId, @Valid @Nullable @Valid String id, @Valid @Nullable @Valid Boolean deep, @Valid @Nullable @Valid Boolean exactName, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Boolean matchingUri, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String name, @Valid @Nullable @Valid String owner, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String type, @Valid @Nullable @Valid String uri)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/resource/{resource-id}/scopes
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdScopesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      resourceId - (required)
      id - (optional)
      deep - (optional)
      exactName - (optional)
      first - (optional)
      matchingUri - (optional)
      max - (optional)
      name - (optional)
      owner - (optional)
      scope - (optional)
      type - (optional)
      uri - (optional)
      Returns:
      OK (status code 200) or Not found (status code 404)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerResourceSearchGet

      public reactor.core.publisher.Mono<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceSearchGet(String realm, String clientUuid, @Valid @Nullable @Valid String id, @Valid @Nullable @Valid Boolean deep, @Valid @Nullable @Valid Boolean exactName, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Boolean matchingUri, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String owner, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String type, @Valid @Nullable @Valid String uri, @Valid @Nullable @Valid String name)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/resource/search
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerResourceSearchGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      id - (optional)
      deep - (optional)
      exactName - (optional)
      first - (optional)
      matchingUri - (optional)
      max - (optional)
      owner - (optional)
      scope - (optional)
      type - (optional)
      uri - (optional)
      name - (optional)
      Returns:
      OK (status code 200) or Bad Request (status code 400) or No Content (status code 204)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerScopeGet

      public reactor.core.publisher.Flux<ScopeRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeGet(String realm, String clientUuid, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String name, @Valid @Nullable @Valid String scopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/scope
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerScopeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      first - (optional)
      max - (optional)
      name - (optional)
      scopeId - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerScopePost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerScopePost(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Mono<ScopeRepresentation> scopeRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/scope
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerScopePost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      scopeRepresentation - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdDelete(String realm, String clientUuid, String scopeId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/scope/{scope-id}
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      scopeId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdGet

      public reactor.core.publisher.Mono<ScopeRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdGet(String realm, String clientUuid, String scopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/scope/{scope-id}
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      scopeId - (required)
      Returns:
      OK (status code 200) or Not found (status code 404)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdPermissionsGet

      public reactor.core.publisher.Flux<PolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdPermissionsGet(String realm, String clientUuid, String scopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/scope/{scope-id}/permissions
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdPermissionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      scopeId - (required)
      Returns:
      OK (status code 200) or Not found (status code 404)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdPut(String realm, String clientUuid, String scopeId, @Valid @Valid reactor.core.publisher.Mono<ScopeRepresentation> scopeRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/scope/{scope-id}
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      scopeId - (required)
      scopeRepresentation - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdResourcesGet

      public reactor.core.publisher.Flux<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdResourcesGet(String realm, String clientUuid, String scopeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/scope/{scope-id}/resources
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdResourcesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      scopeId - (required)
      Returns:
      OK (status code 200) or Not found (status code 404)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerScopeSearchGet

      public reactor.core.publisher.Flux<ScopeRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeSearchGet(String realm, String clientUuid, @Valid @Nullable @Valid String name)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/scope/search
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerScopeSearchGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      name - (optional)
      Returns:
      OK (status code 200) or No Content (status code 204) or Bad Request (status code 400)
    • adminRealmsRealmClientsClientUuidAuthzResourceServerSettingsGet

      public reactor.core.publisher.Mono<ResourceServerRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerSettingsGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/authz/resource-server/settings
      Specified by:
      adminRealmsRealmClientsClientUuidAuthzResourceServerSettingsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidCertificatesAttrDownloadPost

      public reactor.core.publisher.Mono<org.springframework.core.io.Resource> adminRealmsRealmClientsClientUuidCertificatesAttrDownloadPost(String realm, String clientUuid, String attr, @Valid @Valid reactor.core.publisher.Mono<KeyStoreConfig> keyStoreConfig)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/certificates/{attr}/download : Get a keystore file for the client, containing private key and public certificate
      Specified by:
      adminRealmsRealmClientsClientUuidCertificatesAttrDownloadPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      attr - (required)
      keyStoreConfig - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidCertificatesAttrGenerateAndDownloadPost

      public reactor.core.publisher.Mono<org.springframework.core.io.Resource> adminRealmsRealmClientsClientUuidCertificatesAttrGenerateAndDownloadPost(String realm, String clientUuid, String attr, @Valid @Valid reactor.core.publisher.Mono<KeyStoreConfig> keyStoreConfig)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/certificates/{attr}/generate-and-download : 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. Only generated public certificate is saved in Keycloak DB - the private key is not.
      Specified by:
      adminRealmsRealmClientsClientUuidCertificatesAttrGenerateAndDownloadPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      attr - (required)
      keyStoreConfig - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidCertificatesAttrGeneratePost

      public reactor.core.publisher.Mono<CertificateRepresentation> adminRealmsRealmClientsClientUuidCertificatesAttrGeneratePost(String realm, String clientUuid, String attr)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/certificates/{attr}/generate : Generate a new certificate with new key pair
      Specified by:
      adminRealmsRealmClientsClientUuidCertificatesAttrGeneratePost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      attr - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidCertificatesAttrGet

      public reactor.core.publisher.Mono<CertificateRepresentation> adminRealmsRealmClientsClientUuidCertificatesAttrGet(String realm, String clientUuid, String attr)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/certificates/{attr} : Get key info
      Specified by:
      adminRealmsRealmClientsClientUuidCertificatesAttrGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      attr - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidCertificatesAttrUploadCertificatePost

      public reactor.core.publisher.Mono<CertificateRepresentation> adminRealmsRealmClientsClientUuidCertificatesAttrUploadCertificatePost(String realm, String clientUuid, String attr)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/certificates/{attr}/upload-certificate : Upload only certificate, not private key
      Specified by:
      adminRealmsRealmClientsClientUuidCertificatesAttrUploadCertificatePost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      attr - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidCertificatesAttrUploadPost

      public reactor.core.publisher.Mono<CertificateRepresentation> adminRealmsRealmClientsClientUuidCertificatesAttrUploadPost(String realm, String clientUuid, String attr)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/certificates/{attr}/upload : Upload certificate and eventually private key
      Specified by:
      adminRealmsRealmClientsClientUuidCertificatesAttrUploadPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      attr - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidClientSecretGet

      public reactor.core.publisher.Mono<CredentialRepresentation> adminRealmsRealmClientsClientUuidClientSecretGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/client-secret : Get the client secret
      Specified by:
      adminRealmsRealmClientsClientUuidClientSecretGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidClientSecretPost

      public reactor.core.publisher.Mono<CredentialRepresentation> adminRealmsRealmClientsClientUuidClientSecretPost(String realm, String clientUuid)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/client-secret : Generate a new secret for the client
      Specified by:
      adminRealmsRealmClientsClientUuidClientSecretPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidClientSecretRotatedDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidClientSecretRotatedDelete(String realm, String clientUuid)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients/{client-uuid}/client-secret/rotated : Invalidate the rotated secret for the client
      Specified by:
      adminRealmsRealmClientsClientUuidClientSecretRotatedDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidClientSecretRotatedGet

      public reactor.core.publisher.Mono<CredentialRepresentation> adminRealmsRealmClientsClientUuidClientSecretRotatedGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/client-secret/rotated : Get the rotated client secret
      Specified by:
      adminRealmsRealmClientsClientUuidClientSecretRotatedGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidDefaultClientScopesClientScopeIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidDefaultClientScopesClientScopeIdDelete(String realm, String clientUuid, String clientScopeId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients/{client-uuid}/default-client-scopes/{clientScopeId}
      Specified by:
      adminRealmsRealmClientsClientUuidDefaultClientScopesClientScopeIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      clientScopeId - (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidDefaultClientScopesClientScopeIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidDefaultClientScopesClientScopeIdPut(String realm, String clientUuid, String clientScopeId)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/clients/{client-uuid}/default-client-scopes/{clientScopeId}
      Specified by:
      adminRealmsRealmClientsClientUuidDefaultClientScopesClientScopeIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      clientScopeId - (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidDefaultClientScopesGet

      public reactor.core.publisher.Flux<ClientScopeRepresentation> adminRealmsRealmClientsClientUuidDefaultClientScopesGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/default-client-scopes : Get default client scopes. Only name and ids are returned.
      Specified by:
      adminRealmsRealmClientsClientUuidDefaultClientScopesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidDelete(String realm, String clientUuid)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients/{client-uuid} : Delete the client
      Specified by:
      adminRealmsRealmClientsClientUuidDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleAccessTokenGet

      public reactor.core.publisher.Mono<AccessToken> adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleAccessTokenGet(String realm, String clientUuid, @Valid @Nullable @Valid String audience, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/evaluate-scopes/generate-example-access-token : Create JSON with payload of example access token
      Specified by:
      adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleAccessTokenGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      audience - (optional)
      scope - (optional)
      userId - (optional)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleIdTokenGet

      public reactor.core.publisher.Mono<IDToken> adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleIdTokenGet(String realm, String clientUuid, @Valid @Nullable @Valid String audience, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/evaluate-scopes/generate-example-id-token : Create JSON with payload of example id token
      Specified by:
      adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleIdTokenGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      audience - (optional)
      scope - (optional)
      userId - (optional)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleSamlResponseGet

      public reactor.core.publisher.Mono<SamlExampleResponse> adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleSamlResponseGet(String realm, String clientUuid, @Valid @Nullable @Valid String audience, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/evaluate-scopes/generate-example-saml-response : Create JSON with an example SAML response as payload
      Specified by:
      adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleSamlResponseGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      audience - (optional)
      scope - (optional)
      userId - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleUserinfoGet

      public reactor.core.publisher.Mono<Object> adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleUserinfoGet(String realm, String clientUuid, @Valid @Nullable @Valid String scope, @Valid @Nullable @Valid String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/evaluate-scopes/generate-example-userinfo : Create JSON with payload of example user info
      Specified by:
      adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleUserinfoGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      scope - (optional)
      userId - (optional)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmClientsClientUuidEvaluateScopesProtocolMappersGet

      public reactor.core.publisher.Flux<ProtocolMapperEvaluationRepresentation> adminRealmsRealmClientsClientUuidEvaluateScopesProtocolMappersGet(String realm, String clientUuid, @Valid @Nullable @Valid String scope)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/evaluate-scopes/protocol-mappers : Return list of all protocol mappers, which will be used when generating tokens issued for particular client. This means protocol mappers assigned to this client directly and protocol mappers assigned to all client scopes of this client.
      Specified by:
      adminRealmsRealmClientsClientUuidEvaluateScopesProtocolMappersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      scope - (optional)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmClientsClientUuidEvaluateScopesScopeMappingsRoleContainerIdGrantedGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidEvaluateScopesScopeMappingsRoleContainerIdGrantedGet(String realm, String clientUuid, String roleContainerId, @Valid @Nullable @Valid String scope)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/evaluate-scopes/scope-mappings/{roleContainerId}/granted : Get effective scope mapping of all roles of particular role container, which this client is defacto allowed to have in the accessToken issued for him. This contains scope mappings, which this client has directly, as well as scope mappings, which are granted to all client scopes, which are linked with this client.
      Specified by:
      adminRealmsRealmClientsClientUuidEvaluateScopesScopeMappingsRoleContainerIdGrantedGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleContainerId - either realm name OR client UUID (required)
      scope - (optional)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmClientsClientUuidEvaluateScopesScopeMappingsRoleContainerIdNotGrantedGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidEvaluateScopesScopeMappingsRoleContainerIdNotGrantedGet(String realm, String clientUuid, String roleContainerId, @Valid @Nullable @Valid String scope)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/evaluate-scopes/scope-mappings/{roleContainerId}/not-granted : Get roles, which this client doesn't have scope for and can't have them in the accessToken issued for him. Defacto all the other roles of particular role container, which are not in
      invalid reference
      #getGrantedScopeMappings()
      Specified by:
      adminRealmsRealmClientsClientUuidEvaluateScopesScopeMappingsRoleContainerIdNotGrantedGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleContainerId - either realm name OR client UUID (required)
      scope - (optional)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmClientsClientUuidGet

      public reactor.core.publisher.Mono<ClientRepresentation> adminRealmsRealmClientsClientUuidGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid} : Get representation of the client
      Specified by:
      adminRealmsRealmClientsClientUuidGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidInstallationProvidersProviderIdGet

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidInstallationProvidersProviderIdGet(String realm, String clientUuid, String providerId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/installation/providers/{providerId}
      Specified by:
      adminRealmsRealmClientsClientUuidInstallationProvidersProviderIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      providerId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidManagementPermissionsGet

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmClientsClientUuidManagementPermissionsGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/management/permissions : Return object stating whether client Authorization permissions have been initialized or not and a reference
      Specified by:
      adminRealmsRealmClientsClientUuidManagementPermissionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidManagementPermissionsPut

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmClientsClientUuidManagementPermissionsPut(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Mono<ManagementPermissionReference> managementPermissionReference)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/clients/{client-uuid}/management/permissions : Return object stating whether client Authorization permissions have been initialized or not and a reference
      Specified by:
      adminRealmsRealmClientsClientUuidManagementPermissionsPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      managementPermissionReference - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidNodesNodeDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidNodesNodeDelete(String realm, String clientUuid, String node)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients/{client-uuid}/nodes/{node} : Unregister a cluster node from the client
      Specified by:
      adminRealmsRealmClientsClientUuidNodesNodeDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      node - (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidNodesPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidNodesPost(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Mono<Map<String,String>> requestBody)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/nodes : Register a cluster node with the client Manually register cluster node to this client - usually it’s not needed to call this directly as adapter should handle by sending registration request to Keycloak
      Specified by:
      adminRealmsRealmClientsClientUuidNodesPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      requestBody - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidOfflineSessionCountGet

      public reactor.core.publisher.Mono<Map<String,Long>> adminRealmsRealmClientsClientUuidOfflineSessionCountGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/offline-session-count : Get application offline session count Returns a number of offline user sessions associated with this client { \"count\": number }
      Specified by:
      adminRealmsRealmClientsClientUuidOfflineSessionCountGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidOfflineSessionsGet

      public reactor.core.publisher.Flux<UserSessionRepresentation> adminRealmsRealmClientsClientUuidOfflineSessionsGet(String realm, String clientUuid, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/offline-sessions : Get offline sessions for client. Returns a list of offline user sessions associated with this client
      Specified by:
      adminRealmsRealmClientsClientUuidOfflineSessionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      first - Paging offset (optional)
      max - Maximum results size. (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidOptionalClientScopesClientScopeIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidOptionalClientScopesClientScopeIdDelete(String realm, String clientUuid, String clientScopeId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients/{client-uuid}/optional-client-scopes/{clientScopeId}
      Specified by:
      adminRealmsRealmClientsClientUuidOptionalClientScopesClientScopeIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      clientScopeId - (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidOptionalClientScopesClientScopeIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidOptionalClientScopesClientScopeIdPut(String realm, String clientUuid, String clientScopeId)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/clients/{client-uuid}/optional-client-scopes/{clientScopeId}
      Specified by:
      adminRealmsRealmClientsClientUuidOptionalClientScopesClientScopeIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      clientScopeId - (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidOptionalClientScopesGet

      public reactor.core.publisher.Flux<ClientScopeRepresentation> adminRealmsRealmClientsClientUuidOptionalClientScopesGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/optional-client-scopes : Get optional client scopes. Only name and ids are returned.
      Specified by:
      adminRealmsRealmClientsClientUuidOptionalClientScopesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidProtocolMappersAddModelsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidProtocolMappersAddModelsPost(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Flux<ProtocolMapperRepresentation> protocolMapperRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/add-models : Create multiple mappers
      Specified by:
      adminRealmsRealmClientsClientUuidProtocolMappersAddModelsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      protocolMapperRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidProtocolMappersModelsGet

      public reactor.core.publisher.Flux<ProtocolMapperRepresentation> adminRealmsRealmClientsClientUuidProtocolMappersModelsGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/models : Get mappers
      Specified by:
      adminRealmsRealmClientsClientUuidProtocolMappersModelsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidProtocolMappersModelsIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidProtocolMappersModelsIdDelete(String realm, String clientUuid, String id)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/models/{id} : Delete the mapper
      Specified by:
      adminRealmsRealmClientsClientUuidProtocolMappersModelsIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      id - Mapper id (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidProtocolMappersModelsIdGet

      public reactor.core.publisher.Mono<ProtocolMapperRepresentation> adminRealmsRealmClientsClientUuidProtocolMappersModelsIdGet(String realm, String clientUuid, String id)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/models/{id} : Get mapper by id
      Specified by:
      adminRealmsRealmClientsClientUuidProtocolMappersModelsIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      id - Mapper id (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidProtocolMappersModelsIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidProtocolMappersModelsIdPut(String realm, String clientUuid, String id, @Valid @Valid reactor.core.publisher.Mono<ProtocolMapperRepresentation> protocolMapperRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/models/{id} : Update the mapper
      Specified by:
      adminRealmsRealmClientsClientUuidProtocolMappersModelsIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      id - Mapper id (required)
      protocolMapperRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidProtocolMappersModelsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidProtocolMappersModelsPost(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Mono<ProtocolMapperRepresentation> protocolMapperRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/models : Create a mapper
      Specified by:
      adminRealmsRealmClientsClientUuidProtocolMappersModelsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      protocolMapperRepresentation - (optional)
      Returns:
      Created (status code 201) or Conflict (status code 409)
    • adminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGet

      public reactor.core.publisher.Flux<ProtocolMapperRepresentation> adminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGet(String realm, String clientUuid, String protocol)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/protocol-mappers/protocol/{protocol} : Get mappers by name for a specific protocol
      Specified by:
      adminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      protocol - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidPushRevocationPost

      public reactor.core.publisher.Mono<GlobalRequestResult> adminRealmsRealmClientsClientUuidPushRevocationPost(String realm, String clientUuid)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/push-revocation : Push the client's revocation policy to its admin URL If the client has an admin URL, push revocation policy to it.
      Specified by:
      adminRealmsRealmClientsClientUuidPushRevocationPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidPut(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Mono<ClientRepresentation> clientRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/clients/{client-uuid} : Update the client
      Specified by:
      adminRealmsRealmClientsClientUuidPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      clientRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Conflict (status code 409)
    • adminRealmsRealmClientsClientUuidRegistrationAccessTokenPost

      public reactor.core.publisher.Mono<ClientRepresentation> adminRealmsRealmClientsClientUuidRegistrationAccessTokenPost(String realm, String clientUuid)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/registration-access-token : Generate a new registration access token for the client
      Specified by:
      adminRealmsRealmClientsClientUuidRegistrationAccessTokenPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidRolesGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesGet(String realm, String clientUuid, @Valid @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Valid String search)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/roles : Get all roles for the realm or client
      Specified by:
      adminRealmsRealmClientsClientUuidRolesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      briefRepresentation - (optional, default to true)
      first - (optional)
      max - (optional)
      search - (optional, default to )
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmClientsClientUuidRolesPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidRolesPost(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Mono<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/roles : Create a new role for the realm or client
      Specified by:
      adminRealmsRealmClientsClientUuidRolesPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleRepresentation - (optional)
      Returns:
      Created (status code 201) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Conflict (status code 409) or Internal Server Error (status code 500)
    • adminRealmsRealmClientsClientUuidRolesRoleNameCompositesClientsTargetClientUuidGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesClientsTargetClientUuidGet(String realm, String clientUuid, String roleName, String targetClientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/roles/{role-name}/composites/clients/{targetClientUuid} : Get client-level roles for the client that are in the role's composite
      Specified by:
      adminRealmsRealmClientsClientUuidRolesRoleNameCompositesClientsTargetClientUuidGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleName - role's name (not id!) (required)
      targetClientUuid - (required)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidRolesRoleNameCompositesDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesDelete(String realm, String clientUuid, String roleName, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients/{client-uuid}/roles/{role-name}/composites : Remove roles from the role's composite
      Specified by:
      adminRealmsRealmClientsClientUuidRolesRoleNameCompositesDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleName - role's name (not id!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidRolesRoleNameCompositesGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesGet(String realm, String clientUuid, String roleName)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/roles/{role-name}/composites : Get composites of the role
      Specified by:
      adminRealmsRealmClientsClientUuidRolesRoleNameCompositesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleName - role's name (not id!) (required)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidRolesRoleNameCompositesPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesPost(String realm, String clientUuid, String roleName, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/roles/{role-name}/composites : Add a composite to the role
      Specified by:
      adminRealmsRealmClientsClientUuidRolesRoleNameCompositesPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleName - role's name (not id!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidRolesRoleNameCompositesRealmGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesRealmGet(String realm, String clientUuid, String roleName)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/roles/{role-name}/composites/realm : Get realm-level roles of the role's composite
      Specified by:
      adminRealmsRealmClientsClientUuidRolesRoleNameCompositesRealmGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleName - role's name (not id!) (required)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidRolesRoleNameDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidRolesRoleNameDelete(String realm, String clientUuid, String roleName)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients/{client-uuid}/roles/{role-name} : Delete a role by name
      Specified by:
      adminRealmsRealmClientsClientUuidRolesRoleNameDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleName - role's name (not id!) (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidRolesRoleNameGet

      public reactor.core.publisher.Mono<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameGet(String realm, String clientUuid, String roleName)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/roles/{role-name} : Get a role by name
      Specified by:
      adminRealmsRealmClientsClientUuidRolesRoleNameGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleName - role's name (not id!) (required)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidRolesRoleNameGroupsGet

      public reactor.core.publisher.Flux<UserRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameGroupsGet(String realm, String clientUuid, String roleName, @Valid @Nullable @Valid Integer max, @Valid @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Integer first)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/roles/{role-name}/groups : Returns a stream of groups that have the specified role name
      Specified by:
      adminRealmsRealmClientsClientUuidRolesRoleNameGroupsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleName - the role name. (required)
      max - Maximum number of results to return. Unbounded if negative. (optional)
      briefRepresentation - If false, return a full representation of the GroupRepresentation objects. (optional, default to true)
      first - First result to return. Ignored if negative or null. (optional)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidRolesRoleNameManagementPermissionsGet

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmClientsClientUuidRolesRoleNameManagementPermissionsGet(String realm, String clientUuid, String roleName)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/roles/{role-name}/management/permissions : Return object stating whether role Authorization permissions have been initialized or not and a reference
      Specified by:
      adminRealmsRealmClientsClientUuidRolesRoleNameManagementPermissionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleName - (required)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidRolesRoleNameManagementPermissionsPut

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmClientsClientUuidRolesRoleNameManagementPermissionsPut(String realm, String clientUuid, String roleName, @Valid @Valid reactor.core.publisher.Mono<ManagementPermissionReference> managementPermissionReference)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/clients/{client-uuid}/roles/{role-name}/management/permissions : Return object stating whether role Authorization permissions have been initialized or not and a reference
      Specified by:
      adminRealmsRealmClientsClientUuidRolesRoleNameManagementPermissionsPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleName - (required)
      managementPermissionReference - (optional)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidRolesRoleNamePut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidRolesRoleNamePut(String realm, String clientUuid, String roleName, @Valid @Valid reactor.core.publisher.Mono<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/clients/{client-uuid}/roles/{role-name} : Update a role by name
      Specified by:
      adminRealmsRealmClientsClientUuidRolesRoleNamePut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleName - role's name (not id!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Conflict (status code 409)
    • adminRealmsRealmClientsClientUuidRolesRoleNameUsersGet

      public reactor.core.publisher.Flux<UserRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameUsersGet(String realm, String clientUuid, String roleName, @Valid @Nullable @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/roles/{role-name}/users : Returns a stream of users that have the specified role name.
      Specified by:
      adminRealmsRealmClientsClientUuidRolesRoleNameUsersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleName - the role name. (required)
      briefRepresentation - Boolean which defines whether brief representations are returned (default: false) (optional)
      first - first result to return. Ignored if negative or null. (optional)
      max - Maximum number of results to return. Unbounded if negative. (optional)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmClientsClientUuidScopeMappingsClientsClientAvailableGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientAvailableGet(String realm, String clientUuid, String client)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/scope-mappings/clients/{client}/available : The available client-level roles Returns the roles for the client that can be associated with the client's scope
      Specified by:
      adminRealmsRealmClientsClientUuidScopeMappingsClientsClientAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      client - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidScopeMappingsClientsClientCompositeGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientCompositeGet(String realm, String clientUuid, String client, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/scope-mappings/clients/{client}/composite : Get effective client roles Returns the roles for the client that are associated with the client's scope.
      Specified by:
      adminRealmsRealmClientsClientUuidScopeMappingsClientsClientCompositeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      client - (required)
      briefRepresentation - if false, return roles with their attributes (optional, default to true)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidScopeMappingsClientsClientDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientDelete(String realm, String clientUuid, String client, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients/{client-uuid}/scope-mappings/clients/{client} : Remove client-level roles from the client's scope.
      Specified by:
      adminRealmsRealmClientsClientUuidScopeMappingsClientsClientDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      client - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidScopeMappingsClientsClientGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientGet(String realm, String clientUuid, String client)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/scope-mappings/clients/{client} : Get the roles associated with a client's scope Returns roles for the client.
      Specified by:
      adminRealmsRealmClientsClientUuidScopeMappingsClientsClientGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      client - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidScopeMappingsClientsClientPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientPost(String realm, String clientUuid, String client, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/scope-mappings/clients/{client} : Add client-level roles to the client's scope
      Specified by:
      adminRealmsRealmClientsClientUuidScopeMappingsClientsClientPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      client - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidScopeMappingsGet

      public reactor.core.publisher.Mono<MappingsRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/scope-mappings : Get all scope mappings for the client
      Specified by:
      adminRealmsRealmClientsClientUuidScopeMappingsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidScopeMappingsRealmAvailableGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsRealmAvailableGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/scope-mappings/realm/available : Get realm-level roles that are available to attach to this client's scope
      Specified by:
      adminRealmsRealmClientsClientUuidScopeMappingsRealmAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidScopeMappingsRealmCompositeGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsRealmCompositeGet(String realm, String clientUuid, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/scope-mappings/realm/composite : Get effective realm-level roles associated with the client’s scope What this does is recurse any composite roles associated with the client’s scope and adds the roles to this lists. The method is really to show a comprehensive total view of realm-level roles associated with the client.
      Specified by:
      adminRealmsRealmClientsClientUuidScopeMappingsRealmCompositeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      briefRepresentation - if false, return roles with their attributes (optional, default to true)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidScopeMappingsRealmDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidScopeMappingsRealmDelete(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients/{client-uuid}/scope-mappings/realm : Remove a set of realm-level roles from the client's scope
      Specified by:
      adminRealmsRealmClientsClientUuidScopeMappingsRealmDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidScopeMappingsRealmGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsRealmGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/scope-mappings/realm : Get realm-level roles associated with the client's scope
      Specified by:
      adminRealmsRealmClientsClientUuidScopeMappingsRealmGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidScopeMappingsRealmPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsClientUuidScopeMappingsRealmPost(String realm, String clientUuid, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients/{client-uuid}/scope-mappings/realm : Add a set of realm-level roles to the client's scope
      Specified by:
      adminRealmsRealmClientsClientUuidScopeMappingsRealmPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsClientUuidServiceAccountUserGet

      public reactor.core.publisher.Mono<UserRepresentation> adminRealmsRealmClientsClientUuidServiceAccountUserGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/service-account-user : Get a user dedicated to the service account
      Specified by:
      adminRealmsRealmClientsClientUuidServiceAccountUserGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidSessionCountGet

      public reactor.core.publisher.Mono<Map<String,Long>> adminRealmsRealmClientsClientUuidSessionCountGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/session-count : Get application session count Returns a number of user sessions associated with this client { \"count\": number }
      Specified by:
      adminRealmsRealmClientsClientUuidSessionCountGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidTestNodesAvailableGet

      public reactor.core.publisher.Mono<GlobalRequestResult> adminRealmsRealmClientsClientUuidTestNodesAvailableGet(String realm, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/test-nodes-available : Test if registered cluster nodes are available Tests availability by sending 'ping' request to all cluster nodes.
      Specified by:
      adminRealmsRealmClientsClientUuidTestNodesAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsClientUuidUserSessionsGet

      public reactor.core.publisher.Flux<UserSessionRepresentation> adminRealmsRealmClientsClientUuidUserSessionsGet(String realm, String clientUuid, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients/{client-uuid}/user-sessions : Get user sessions for client. Returns a list of user sessions associated with this client.
      Specified by:
      adminRealmsRealmClientsClientUuidUserSessionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - id of client (not client-id!) (required)
      first - Paging offset (optional)
      max - Maximum results size. (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsGet

      public reactor.core.publisher.Flux<ClientRepresentation> adminRealmsRealmClientsGet(String realm, @Valid @Nullable @Valid String clientId, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String q, @Valid @Valid Boolean search, @Valid @Valid Boolean viewableOnly)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients : Get clients belonging to the realm. If a client can’t be retrieved from the storage due to a problem with the underlying storage, it is silently removed from the returned list. This ensures that concurrent modifications to the list don’t prevent callers from retrieving this list.
      Specified by:
      adminRealmsRealmClientsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientId - filter by clientId (optional)
      first - the first result (optional)
      max - the max results to return (optional)
      q - (optional)
      search - whether this is a search query or a getClientById query (optional, default to false)
      viewableOnly - filter clients that cannot be viewed in full by admin (optional, default to false)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsInitialAccessGet

      public reactor.core.publisher.Flux<ClientInitialAccessPresentation> adminRealmsRealmClientsInitialAccessGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/clients-initial-access
      Specified by:
      adminRealmsRealmClientsInitialAccessGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmClientsInitialAccessIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsInitialAccessIdDelete(String realm, String id)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/clients-initial-access/{id}
      Specified by:
      adminRealmsRealmClientsInitialAccessIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmClientsInitialAccessPost

      public reactor.core.publisher.Mono<ClientInitialAccessCreatePresentation> adminRealmsRealmClientsInitialAccessPost(String realm, @Valid @Valid reactor.core.publisher.Mono<ClientInitialAccessCreatePresentation> clientInitialAccessCreatePresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients-initial-access : Create a new initial access token.
      Specified by:
      adminRealmsRealmClientsInitialAccessPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientInitialAccessCreatePresentation - (optional)
      Returns:
      Created (status code 201)
    • adminRealmsRealmClientsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmClientsPost(String realm, @Valid @Valid reactor.core.publisher.Mono<ClientRepresentation> clientRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/clients : Create a new client Client’s client_id must be unique!
      Specified by:
      adminRealmsRealmClientsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientRepresentation - (optional)
      Returns:
      Created (status code 201) or Conflict (status code 409)
    • adminRealmsRealmComponentsGet

      public reactor.core.publisher.Flux<ComponentRepresentation> adminRealmsRealmComponentsGet(String realm, @Valid @Nullable @Valid String name, @Valid @Nullable @Valid String parent, @Valid @Nullable @Valid String providerId, @Valid @Nullable @Valid String type)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/components
      Specified by:
      adminRealmsRealmComponentsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      name - (optional)
      parent - (optional)
      providerId - (optional)
      type - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmComponentsIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmComponentsIdDelete(String realm, String id)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/components/{id}
      Specified by:
      adminRealmsRealmComponentsIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmComponentsIdGet

      public reactor.core.publisher.Mono<ComponentRepresentation> adminRealmsRealmComponentsIdGet(String realm, String id)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/components/{id}
      Specified by:
      adminRealmsRealmComponentsIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmComponentsIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmComponentsIdPut(String realm, String id, @Valid @Valid reactor.core.publisher.Mono<ComponentRepresentation> componentRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/components/{id}
      Specified by:
      adminRealmsRealmComponentsIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - (required)
      componentRepresentation - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmComponentsIdSubComponentTypesGet

      public reactor.core.publisher.Flux<ComponentTypeRepresentation> adminRealmsRealmComponentsIdSubComponentTypesGet(String realm, String id, @Valid @Nullable @Valid String type)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/components/{id}/sub-component-types : List of subcomponent types that are available to configure for a particular parent component.
      Specified by:
      adminRealmsRealmComponentsIdSubComponentTypesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - (required)
      type - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmComponentsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmComponentsPost(String realm, @Valid @Valid reactor.core.publisher.Mono<ComponentRepresentation> componentRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/components
      Specified by:
      adminRealmsRealmComponentsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      componentRepresentation - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmCredentialRegistratorsGet

      public reactor.core.publisher.Mono<List<String>> adminRealmsRealmCredentialRegistratorsGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/credential-registrators
      Specified by:
      adminRealmsRealmCredentialRegistratorsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmDefaultDefaultClientScopesClientScopeIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmDefaultDefaultClientScopesClientScopeIdDelete(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/default-default-client-scopes/{clientScopeId}
      Specified by:
      adminRealmsRealmDefaultDefaultClientScopesClientScopeIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmDefaultDefaultClientScopesClientScopeIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmDefaultDefaultClientScopesClientScopeIdPut(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/default-default-client-scopes/{clientScopeId}
      Specified by:
      adminRealmsRealmDefaultDefaultClientScopesClientScopeIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmDefaultDefaultClientScopesGet

      public reactor.core.publisher.Flux<ClientScopeRepresentation> adminRealmsRealmDefaultDefaultClientScopesGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/default-default-client-scopes : Get realm default client scopes. Only name and ids are returned.
      Specified by:
      adminRealmsRealmDefaultDefaultClientScopesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmDefaultGroupsGet

      public reactor.core.publisher.Flux<GroupRepresentation> adminRealmsRealmDefaultGroupsGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/default-groups : Get group hierarchy. Only name and ids are returned.
      Specified by:
      adminRealmsRealmDefaultGroupsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmDefaultGroupsGroupIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmDefaultGroupsGroupIdDelete(String realm, String groupId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/default-groups/{groupId}
      Specified by:
      adminRealmsRealmDefaultGroupsGroupIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmDefaultGroupsGroupIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmDefaultGroupsGroupIdPut(String realm, String groupId)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/default-groups/{groupId}
      Specified by:
      adminRealmsRealmDefaultGroupsGroupIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmDefaultOptionalClientScopesClientScopeIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmDefaultOptionalClientScopesClientScopeIdDelete(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/default-optional-client-scopes/{clientScopeId}
      Specified by:
      adminRealmsRealmDefaultOptionalClientScopesClientScopeIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmDefaultOptionalClientScopesClientScopeIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmDefaultOptionalClientScopesClientScopeIdPut(String realm, String clientScopeId)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/default-optional-client-scopes/{clientScopeId}
      Specified by:
      adminRealmsRealmDefaultOptionalClientScopesClientScopeIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientScopeId - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmDefaultOptionalClientScopesGet

      public reactor.core.publisher.Flux<ClientScopeRepresentation> adminRealmsRealmDefaultOptionalClientScopesGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/default-optional-client-scopes : Get realm optional client scopes. Only name and ids are returned.
      Specified by:
      adminRealmsRealmDefaultOptionalClientScopesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmDelete(String realm)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm} : Delete the realm
      Specified by:
      adminRealmsRealmDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmEventsConfigGet

      public reactor.core.publisher.Mono<RealmEventsConfigRepresentation> adminRealmsRealmEventsConfigGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/events/config : Get the events provider configuration Returns JSON object with events provider configuration
      Specified by:
      adminRealmsRealmEventsConfigGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmEventsConfigPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmEventsConfigPut(String realm, @Valid @Valid reactor.core.publisher.Mono<RealmEventsConfigRepresentation> realmEventsConfigRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/events/config Update the events provider Change the events provider and/or its configuration
      Specified by:
      adminRealmsRealmEventsConfigPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      realmEventsConfigRepresentation - (optional)
      Returns:
      No Content (status code 204) or Forbidden (status code 403)
    • adminRealmsRealmEventsDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmEventsDelete(String realm)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/events : Delete all events
      Specified by:
      adminRealmsRealmEventsDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403)
    • adminRealmsRealmEventsGet

      public reactor.core.publisher.Flux<EventRepresentation> adminRealmsRealmEventsGet(String realm, @Valid @Nullable @Valid String client, @Valid @Nullable @Valid String dateFrom, @Valid @Nullable @Valid String dateTo, @Valid @Nullable @Valid String direction, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid String ipAddress, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid List<String> type, @Valid @Nullable @Valid String user)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/events : Get events Returns all events, or filters them based on URL query parameters listed here
      Specified by:
      adminRealmsRealmEventsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      client - App or oauth client name (optional)
      dateFrom - From (inclusive) date (yyyy-MM-dd) or time in Epoch timestamp millis (number of milliseconds since January 1, 1970, 00:00:00 GMT) (optional)
      dateTo - To (inclusive) date (yyyy-MM-dd) or time in Epoch timestamp millis (number of milliseconds since January 1, 1970, 00:00:00 GMT) (optional)
      direction - The direction to sort events by (asc or desc) (optional)
      first - Paging offset (optional)
      ipAddress - IP Address (optional)
      max - Maximum results size (optional)
      type - The types of events to return (optional)
      user - User id (optional)
      Returns:
      OK (status code 200) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmGet

      public reactor.core.publisher.Mono<RealmRepresentation> adminRealmsRealmGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm} : Get the top-level representation of the realm It will not include nested information like User and Client representations.
      Specified by:
      adminRealmsRealmGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmGroupByPathPathGet

      public reactor.core.publisher.Mono<GroupRepresentation> adminRealmsRealmGroupByPathPathGet(String realm, @Pattern(regexp=".*") @Pattern(regexp=".*") String path)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/group-by-path/{path}
      Specified by:
      adminRealmsRealmGroupByPathPathGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      path - (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmGroupsCountGet

      public reactor.core.publisher.Mono<Map<String,Long>> adminRealmsRealmGroupsCountGet(String realm, @Valid @Nullable @Valid String search, @Valid @Valid Boolean top)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups/count : Returns the groups counts.
      Specified by:
      adminRealmsRealmGroupsCountGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      search - (optional)
      top - (optional, default to false)
      Returns:
      OK (status code 200)
    • adminRealmsRealmGroupsGet

      public reactor.core.publisher.Flux<GroupRepresentation> adminRealmsRealmGroupsGet(String realm, @Valid @Valid Boolean briefRepresentation, @Valid @Valid Boolean exact, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Valid Boolean populateHierarchy, @Valid @Nullable @Valid String q, @Valid @Nullable @Valid String search, @Valid @Valid Boolean subGroupsCount)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups : Get group hierarchy. Only `name` and `id` are returned. `subGroups` are only returned when using the `search` or `q` parameter. If none of these parameters is provided, the top-level groups are returned without `subGroups` being filled.
      Specified by:
      adminRealmsRealmGroupsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      briefRepresentation - (optional, default to true)
      exact - (optional, default to false)
      first - (optional)
      max - (optional)
      populateHierarchy - (optional, default to true)
      q - (optional)
      search - (optional)
      subGroupsCount - Boolean which defines whether to return the count of subgroups for each group (default: true (optional, default to true)
      Returns:
      OK (status code 200)
    • adminRealmsRealmGroupsGroupIdChildrenGet

      public reactor.core.publisher.Flux<GroupRepresentation> adminRealmsRealmGroupsGroupIdChildrenGet(String realm, String groupId, @Valid @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Boolean exact, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String search, @Valid @Valid Boolean subGroupsCount)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups/{group-id}/children : Return a paginated list of subgroups that have a parent group corresponding to the group on the URL
      Specified by:
      adminRealmsRealmGroupsGroupIdChildrenGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      briefRepresentation - Boolean which defines whether brief groups representations are returned or not (default: false) (optional, default to false)
      exact - Boolean which defines whether the params \"search\" must match exactly or not (optional)
      first - The position of the first result to be returned (pagination offset). (optional)
      max - The maximum number of results that are to be returned. Defaults to 10 (optional)
      search - A String representing either an exact group name or a partial name, defaults to prefix search. (optional)
      subGroupsCount - Boolean which defines whether to return the count of subgroups for each subgroup of this group (default: true) (optional, default to true)
      Returns:
      OK (status code 200)
    • adminRealmsRealmGroupsGroupIdChildrenPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmGroupsGroupIdChildrenPost(String realm, String groupId, @Valid @Valid reactor.core.publisher.Mono<GroupRepresentation> groupRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/groups/{group-id}/children : Set or create child. This will just set the parent if it exists. Create it and set the parent if the group doesn’t exist.
      Specified by:
      adminRealmsRealmGroupsGroupIdChildrenPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      groupRepresentation - (optional)
      Returns:
      Created (status code 201) or No Content (status code 204) or Bad Request (status code 400) or Conflict (status code 409)
    • adminRealmsRealmGroupsGroupIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmGroupsGroupIdDelete(String realm, String groupId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/groups/{group-id}
      Specified by:
      adminRealmsRealmGroupsGroupIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmGroupsGroupIdGet

      public reactor.core.publisher.Mono<GroupRepresentation> adminRealmsRealmGroupsGroupIdGet(String realm, String groupId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups/{group-id}
      Specified by:
      adminRealmsRealmGroupsGroupIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmGroupsGroupIdManagementPermissionsGet

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmGroupsGroupIdManagementPermissionsGet(String realm, String groupId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups/{group-id}/management/permissions : Return object stating whether client Authorization permissions have been initialized or not and a reference
      Specified by:
      adminRealmsRealmGroupsGroupIdManagementPermissionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmGroupsGroupIdManagementPermissionsPut

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmGroupsGroupIdManagementPermissionsPut(String realm, String groupId, @Valid @Valid reactor.core.publisher.Mono<ManagementPermissionReference> managementPermissionReference)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/groups/{group-id}/management/permissions : Return object stating whether client Authorization permissions have been initialized or not and a reference
      Specified by:
      adminRealmsRealmGroupsGroupIdManagementPermissionsPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      managementPermissionReference - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmGroupsGroupIdMembersGet

      public reactor.core.publisher.Flux<UserRepresentation> adminRealmsRealmGroupsGroupIdMembersGet(String realm, String groupId, @Valid @Nullable @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups/{group-id}/members : Get users Returns a stream of users, filtered according to query parameters
      Specified by:
      adminRealmsRealmGroupsGroupIdMembersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      briefRepresentation - Only return basic information (only guaranteed to return id, username, created, first and last name, email, enabled state, email verification state, federation link, and access. Note that it means that namely user attributes, required actions, and not before are not returned.) (optional)
      first - Pagination offset (optional)
      max - Maximum results size (defaults to 100) (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmGroupsGroupIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmGroupsGroupIdPut(String realm, String groupId, @Valid @Valid reactor.core.publisher.Mono<GroupRepresentation> groupRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/groups/{group-id} : Update group, ignores subgroups.
      Specified by:
      adminRealmsRealmGroupsGroupIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      groupRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Conflict (status code 409)
    • adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdAvailableGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdAvailableGet(String realm, String groupId, String clientId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups/{group-id}/role-mappings/clients/{client-id}/available : Get available client-level roles that can be mapped to the user or group
      Specified by:
      adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      clientId - client id (not clientId!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdCompositeGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdCompositeGet(String realm, String groupId, String clientId, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups/{group-id}/role-mappings/clients/{client-id}/composite : Get effective client-level role mappings This recurses any composite roles
      Specified by:
      adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdCompositeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      clientId - client id (not clientId!) (required)
      briefRepresentation - if false, return roles with their attributes (optional, default to true)
      Returns:
      OK (status code 200)
    • adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdDelete(String realm, String groupId, String clientId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/groups/{group-id}/role-mappings/clients/{client-id} : Delete client-level roles from user or group role mapping
      Specified by:
      adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      clientId - client id (not clientId!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdGet(String realm, String groupId, String clientId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups/{group-id}/role-mappings/clients/{client-id} : Get client-level role mappings for the user or group, and the app
      Specified by:
      adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      clientId - client id (not clientId!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdPost(String realm, String groupId, String clientId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/groups/{group-id}/role-mappings/clients/{client-id} : Add client-level roles to the user or group role mapping
      Specified by:
      adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      clientId - client id (not clientId!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmGroupsGroupIdRoleMappingsGet

      public reactor.core.publisher.Mono<MappingsRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsGet(String realm, String groupId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups/{group-id}/role-mappings : Get role mappings
      Specified by:
      adminRealmsRealmGroupsGroupIdRoleMappingsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmGroupsGroupIdRoleMappingsRealmAvailableGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsRealmAvailableGet(String realm, String groupId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups/{group-id}/role-mappings/realm/available : Get realm-level roles that can be mapped
      Specified by:
      adminRealmsRealmGroupsGroupIdRoleMappingsRealmAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmGroupsGroupIdRoleMappingsRealmCompositeGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsRealmCompositeGet(String realm, String groupId, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups/{group-id}/role-mappings/realm/composite : Get effective realm-level role mappings This will recurse all composite roles to get the result.
      Specified by:
      adminRealmsRealmGroupsGroupIdRoleMappingsRealmCompositeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      briefRepresentation - if false, return roles with their attributes (optional, default to true)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmGroupsGroupIdRoleMappingsRealmDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmGroupsGroupIdRoleMappingsRealmDelete(String realm, String groupId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/groups/{group-id}/role-mappings/realm : Delete realm-level role mappings
      Specified by:
      adminRealmsRealmGroupsGroupIdRoleMappingsRealmDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Internal Server Error (status code 500)
    • adminRealmsRealmGroupsGroupIdRoleMappingsRealmGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsRealmGet(String realm, String groupId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/groups/{group-id}/role-mappings/realm : Get realm-level role mappings
      Specified by:
      adminRealmsRealmGroupsGroupIdRoleMappingsRealmGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmGroupsGroupIdRoleMappingsRealmPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmGroupsGroupIdRoleMappingsRealmPost(String realm, String groupId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/groups/{group-id}/role-mappings/realm : Add realm-level role mappings to the user
      Specified by:
      adminRealmsRealmGroupsGroupIdRoleMappingsRealmPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupId - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Internal Server Error (status code 500)
    • adminRealmsRealmGroupsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmGroupsPost(String realm, @Valid @Valid reactor.core.publisher.Mono<GroupRepresentation> groupRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/groups : create or add a top level realm groupSet or create child. This will update the group and set the parent if it exists. Create it and set the parent if the group doesn’t exist.
      Specified by:
      adminRealmsRealmGroupsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      groupRepresentation - (optional)
      Returns:
      Created (status code 201) or No Content (status code 204) or Bad Request (status code 400) or Conflict (status code 409)
    • adminRealmsRealmIdentityProviderImportConfigPost

      public reactor.core.publisher.Mono<Map<String,String>> adminRealmsRealmIdentityProviderImportConfigPost(String realm, @Valid @Valid reactor.core.publisher.Mono<Map<String,Object>> requestBody)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/identity-provider/import-config : Import identity provider from JSON body Import identity provider from uploaded JSON file
      Specified by:
      adminRealmsRealmIdentityProviderImportConfigPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      requestBody - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderInstancesAliasDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasDelete(String realm, String alias)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/identity-provider/instances/{alias} : Delete the identity provider
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderInstancesAliasExportGet

      public reactor.core.publisher.Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasExportGet(String realm, String alias, @Valid @Nullable @Valid String format)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/identity-provider/instances/{alias}/export : Export public broker configuration for identity provider
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasExportGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      format - Format to use (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderInstancesAliasGet

      public reactor.core.publisher.Mono<IdentityProviderRepresentation> adminRealmsRealmIdentityProviderInstancesAliasGet(String realm, String alias)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/identity-provider/instances/{alias} : Get the identity provider
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGet

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGet(String realm, String alias)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/identity-provider/instances/{alias}/management/permissions : Return object stating whether client Authorization permissions have been initialized or not and a reference
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPut

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPut(String realm, String alias, @Valid @Valid reactor.core.publisher.Mono<ManagementPermissionReference> managementPermissionReference)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/identity-provider/instances/{alias}/management/permissions : Return object stating whether client Authorization permissions have been initialized or not and a reference
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      managementPermissionReference - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderInstancesAliasMapperTypesGet

      public reactor.core.publisher.Mono<Map<String,IdentityProviderMapperTypeRepresentation>> adminRealmsRealmIdentityProviderInstancesAliasMapperTypesGet(String realm, String alias)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/identity-provider/instances/{alias}/mapper-types : Get mapper types for identity provider
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasMapperTypesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderInstancesAliasMappersGet

      public reactor.core.publisher.Flux<IdentityProviderMapperRepresentation> adminRealmsRealmIdentityProviderInstancesAliasMappersGet(String realm, String alias)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/identity-provider/instances/{alias}/mappers : Get mappers for identity provider
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasMappersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderInstancesAliasMappersIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasMappersIdDelete(String realm, String alias, String id)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/identity-provider/instances/{alias}/mappers/{id} : Delete a mapper for the identity provider
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasMappersIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      id - Mapper id (required)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmIdentityProviderInstancesAliasMappersIdGet

      public reactor.core.publisher.Mono<IdentityProviderMapperRepresentation> adminRealmsRealmIdentityProviderInstancesAliasMappersIdGet(String realm, String alias, String id)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/identity-provider/instances/{alias}/mappers/{id} : Get mapper by id for the identity provider
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasMappersIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      id - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderInstancesAliasMappersIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasMappersIdPut(String realm, String alias, String id, @Valid @Valid reactor.core.publisher.Mono<IdentityProviderMapperRepresentation> identityProviderMapperRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/identity-provider/instances/{alias}/mappers/{id} : Update a mapper for the identity provider
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasMappersIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      id - Mapper id (required)
      identityProviderMapperRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmIdentityProviderInstancesAliasMappersPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasMappersPost(String realm, String alias, @Valid @Valid reactor.core.publisher.Mono<IdentityProviderMapperRepresentation> identityProviderMapperRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/identity-provider/instances/{alias}/mappers : Add a mapper to identity provider
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasMappersPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      identityProviderMapperRepresentation - (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderInstancesAliasPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasPut(String realm, String alias, @Valid @Valid reactor.core.publisher.Mono<IdentityProviderRepresentation> identityProviderRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/identity-provider/instances/{alias} : Update the identity provider
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      identityProviderRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Conflict (status code 409)
    • adminRealmsRealmIdentityProviderInstancesAliasReloadKeysGet

      public reactor.core.publisher.Mono<Boolean> adminRealmsRealmIdentityProviderInstancesAliasReloadKeysGet(String realm, String alias)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/identity-provider/instances/{alias}/reload-keys : Reaload keys for the identity provider if the provider supports it, \"true\" is returned if reload was performed, \"false\" if not.
      Specified by:
      adminRealmsRealmIdentityProviderInstancesAliasReloadKeysGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      alias - (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderInstancesGet

      public reactor.core.publisher.Flux<IdentityProviderRepresentation> adminRealmsRealmIdentityProviderInstancesGet(String realm, @Valid @Nullable @Valid Boolean briefRepresentation, @Valid @Nullable @Valid String capability, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid Boolean realmOnly, @Valid @Nullable @Valid String search, @Valid @Nullable @Valid String type)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/identity-provider/instances : List identity providers
      Specified by:
      adminRealmsRealmIdentityProviderInstancesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      briefRepresentation - Boolean which defines whether brief representations are returned (default: false) (optional)
      capability - Filter by identity providers capability (optional)
      first - Pagination offset (optional)
      max - Maximum results size (defaults to 100) (optional)
      realmOnly - Boolean which defines if only realm-level IDPs (not associated with orgs) should be returned (default: false) (optional)
      search - Filter specific providers by name. Search can be prefix (name*), contains (*name*) or exact (\"name\"). Default prefixed. (optional)
      type - Filter by identity providers type (optional)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderInstancesPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmIdentityProviderInstancesPost(String realm, @Valid @Valid reactor.core.publisher.Mono<IdentityProviderRepresentation> identityProviderRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/identity-provider/instances : Create a new identity provider
      Specified by:
      adminRealmsRealmIdentityProviderInstancesPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      identityProviderRepresentation - (optional)
      Returns:
      Created (status code 201) or Bad Request (status code 400) or Conflict (status code 409)
    • adminRealmsRealmIdentityProviderProvidersProviderIdGet

      public reactor.core.publisher.Mono<Object> adminRealmsRealmIdentityProviderProvidersProviderIdGet(String realm, String providerId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/identity-provider/providers/{provider_id} : Get the identity provider factory for that provider id
      Specified by:
      adminRealmsRealmIdentityProviderProvidersProviderIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      providerId - The provider id to get the factory (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmIdentityProviderUploadCertificatePost

      public reactor.core.publisher.Mono<CertificateRepresentation> adminRealmsRealmIdentityProviderUploadCertificatePost(String realm)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/identity-provider/upload-certificate : Uploads a certificate, prepares the jwks or public key associated, and returns the certificate representation.
      Specified by:
      adminRealmsRealmIdentityProviderUploadCertificatePost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmKeysGet

      public reactor.core.publisher.Mono<KeysMetadataRepresentation> adminRealmsRealmKeysGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/keys
      Specified by:
      adminRealmsRealmKeysGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmLocalizationGet

      public reactor.core.publisher.Mono<List<String>> adminRealmsRealmLocalizationGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/localization
      Specified by:
      adminRealmsRealmLocalizationGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmLocalizationLocaleDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmLocalizationLocaleDelete(String realm, String locale)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/localization/{locale}
      Specified by:
      adminRealmsRealmLocalizationLocaleDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      locale - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmLocalizationLocaleGet

      public reactor.core.publisher.Mono<Map<String,String>> adminRealmsRealmLocalizationLocaleGet(String realm, String locale, @Valid @Nullable @Valid Boolean useRealmDefaultLocaleFallback)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/localization/{locale}
      Specified by:
      adminRealmsRealmLocalizationLocaleGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      locale - (required)
      useRealmDefaultLocaleFallback - (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmLocalizationLocaleKeyDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmLocalizationLocaleKeyDelete(String realm, String key, String locale)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/localization/{locale}/{key}
      Specified by:
      adminRealmsRealmLocalizationLocaleKeyDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      key - (required)
      locale - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmLocalizationLocaleKeyGet

      public reactor.core.publisher.Mono<String> adminRealmsRealmLocalizationLocaleKeyGet(String realm, String key, String locale)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/localization/{locale}/{key}
      Specified by:
      adminRealmsRealmLocalizationLocaleKeyGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      key - (required)
      locale - (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmLocalizationLocaleKeyPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmLocalizationLocaleKeyPut(String realm, String key, String locale, @Valid @Valid reactor.core.publisher.Mono<String> body)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/localization/{locale}/{key}
      Specified by:
      adminRealmsRealmLocalizationLocaleKeyPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      key - (required)
      locale - (required)
      body - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmLocalizationLocalePost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmLocalizationLocalePost(String realm, String locale, @Valid @Valid reactor.core.publisher.Mono<Map<String,String>> requestBody)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/localization/{locale} : Import localization from uploaded JSON file
      Specified by:
      adminRealmsRealmLocalizationLocalePost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      locale - (required)
      requestBody - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmLogoutAllPost

      public reactor.core.publisher.Mono<GlobalRequestResult> adminRealmsRealmLogoutAllPost(String realm)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/logout-all : Removes all user sessions. Any client that has an admin url will also be told to invalidate any sessions they have.
      Specified by:
      adminRealmsRealmLogoutAllPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsCountGet

      public reactor.core.publisher.Mono<Long> adminRealmsRealmOrganizationsCountGet(String realm, @Valid @Nullable @Valid Boolean exact, @Valid @Nullable @Valid String q, @Valid @Nullable @Valid String search)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/count : Returns the organizations counts.
      Specified by:
      adminRealmsRealmOrganizationsCountGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      exact - Boolean which defines whether the param 'search' must match exactly or not (optional)
      q - A query to search for custom attributes, in the format 'key1:value2 key2:value2' (optional)
      search - A String representing either an organization name or domain (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsGet

      public reactor.core.publisher.Flux<OrganizationRepresentation> adminRealmsRealmOrganizationsGet(String realm, @Valid @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Boolean exact, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String q, @Valid @Nullable @Valid String search)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations : Returns a paginated list of organizations filtered according to the specified parameters
      Specified by:
      adminRealmsRealmOrganizationsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      briefRepresentation - if false, return the full representation. Otherwise, only the basic fields are returned. (optional, default to true)
      exact - Boolean which defines whether the param 'search' must match exactly or not (optional)
      first - The position of the first result to be processed (pagination offset) (optional)
      max - The maximum number of results to be returned - defaults to 10 (optional)
      q - A query to search for custom attributes, in the format 'key1:value2 key2:value2' (optional)
      search - A String representing either an organization name or domain (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmOrganizationsMembersMemberIdOrganizationsGet

      public reactor.core.publisher.Flux<OrganizationRepresentation> adminRealmsRealmOrganizationsMembersMemberIdOrganizationsGet(String realm, String memberId, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/members/{member-id}/organizations : Returns the organizations associated with the user that has the specified id
      Specified by:
      adminRealmsRealmOrganizationsMembersMemberIdOrganizationsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      memberId - (required)
      briefRepresentation - if false, return the full representation. Otherwise, only the basic fields are returned. (optional, default to true)
      Returns:
      OK (status code 200) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdDelete(String realm, String orgId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/organizations/{org-id} : Deletes the organization
      Specified by:
      adminRealmsRealmOrganizationsOrgIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdGet

      public reactor.core.publisher.Mono<OrganizationRepresentation> adminRealmsRealmOrganizationsOrgIdGet(String realm, String orgId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id} : Returns the organization representation
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdGroupsGet

      public reactor.core.publisher.Flux<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGet(String realm, String orgId, @Valid @Valid Boolean briefRepresentation, @Valid @Valid Boolean exact, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Valid Boolean populateHierarchy, @Valid @Nullable @Valid String q, @Valid @Nullable @Valid String search, @Valid @Valid Boolean subGroupsCount)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/groups : Get organization groups Returns organization groups. When `search` parameter is provided, groups are searched by name. When `q` parameter is provided, groups are searched by attributes. If neither parameter is provided, top-level groups are returned.
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      briefRepresentation - (optional, default to true)
      exact - (optional, default to false)
      first - (optional)
      max - (optional)
      populateHierarchy - (optional, default to false)
      q - (optional)
      search - (optional)
      subGroupsCount - (optional, default to false)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupByPathPathGet

      public reactor.core.publisher.Mono<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupByPathPathGet(String realm, String orgId, @Pattern(regexp=".*") @Pattern(regexp=".*") String path, @Valid @Valid Boolean subGroupsCount)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/groups/group-by-path/{path} : Get organization group by path Returns the organization group with the specified path
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupByPathPathGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      path - (required)
      subGroupsCount - Whether to return the count of subgroups (default: false) (optional, default to false)
      Returns:
      OK (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdChildrenGet

      public reactor.core.publisher.Flux<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdChildrenGet(String realm, String orgId, String groupId, @Valid @Nullable @Valid Boolean exact, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String search, @Valid @Nullable @Valid Boolean subGroupsCount)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/children : Get subgroups of this organization group Returns a paginated stream of subgroups that belong to this organization group
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdChildrenGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      exact - Boolean which defines whether the params \"search\" must match exactly or not (optional)
      first - The position of the first result to be returned (pagination offset). (optional)
      max - The maximum number of results that are to be returned. Defaults to 10 (optional)
      search - A String representing either an exact group name or a partial name (optional)
      subGroupsCount - Whether to return the count of subgroups (default: false) (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdChildrenPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdChildrenPost(String realm, String orgId, String groupId, @Valid @Valid reactor.core.publisher.Mono<GroupRepresentation> groupRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/children : Create or move a subgroup Creates a new subgroup under this organization group. If the group representation includes an ID, moves the existing group to be a child of this group. If no ID is provided, creates a new subgroup.
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdChildrenPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      groupRepresentation - (optional)
      Returns:
      Created (status code 201) or No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Conflict (status code 409)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdDelete(String realm, String orgId, String groupId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/organizations/{org-id}/groups/{group-id} : Delete the organization group Deletes the organization group and all its subgroups
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdGet

      public reactor.core.publisher.Mono<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdGet(String realm, String orgId, String groupId, @Valid @Valid Boolean subGroupsCount)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/groups/{group-id} : Get organization group representation
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      subGroupsCount - Whether to return the count of subgroups (default: false) (optional, default to false)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersGet

      public reactor.core.publisher.Flux<MemberRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersGet(String realm, String orgId, String groupId, @Valid @Nullable @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/members : Get members of this organization group Returns a paginated list of organization members that belong to this group
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      briefRepresentation - Only return basic information (only guaranteed to return id, username, created, first and last name, email, enabled state, email verification state, federation link, and access. Note that it means that namely user attributes, required actions, and not before are not returned.) (optional)
      first - Pagination offset (optional)
      max - Maximum results size (defaults to 100) (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersUserIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersUserIdDelete(String realm, String orgId, String groupId, String userId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/members/{userId} : Remove a user from this organization group Removes a user from this organization group. The user remains a member of the organization.
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersUserIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      userId - (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found - User does not exist (status code 404)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersUserIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersUserIdPut(String realm, String orgId, String groupId, String userId)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/members/{userId} : Add a user to this organization group Adds an organization member to this group. The user must be a member of the organization.
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersUserIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      userId - (required)
      Returns:
      No Content (status code 204) or Bad Request - User is not a member of the organization (status code 400) or Forbidden (status code 403) or Not Found - User does not exist (status code 404) or Conflict - User is already a member of the group (status code 409)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdPut(String realm, String orgId, String groupId, @Valid @Valid reactor.core.publisher.Mono<GroupRepresentation> groupRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/organizations/{org-id}/groups/{group-id} : Update organization group Updates the organization group's name, description, and attributes. Subgroups are not affected.
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      groupRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Conflict (status code 409)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdAvailableGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdAvailableGet(String realm, String orgId, String groupId, String clientId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/role-mappings/clients/{client-id}/available : Get available client-level roles that can be mapped to the user or group
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      clientId - client id (not clientId!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdCompositeGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdCompositeGet(String realm, String orgId, String groupId, String clientId, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/role-mappings/clients/{client-id}/composite : Get effective client-level role mappings This recurses any composite roles
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdCompositeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      clientId - client id (not clientId!) (required)
      briefRepresentation - if false, return roles with their attributes (optional, default to true)
      Returns:
      OK (status code 200)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdDelete(String realm, String orgId, String groupId, String clientId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/role-mappings/clients/{client-id} : Delete client-level roles from user or group role mapping
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      clientId - client id (not clientId!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdGet(String realm, String orgId, String groupId, String clientId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/role-mappings/clients/{client-id} : Get client-level role mappings for the user or group, and the app
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      clientId - client id (not clientId!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdPost(String realm, String orgId, String groupId, String clientId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/role-mappings/clients/{client-id} : Add client-level roles to the user or group role mapping
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      clientId - client id (not clientId!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsGet

      public reactor.core.publisher.Mono<MappingsRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsGet(String realm, String orgId, String groupId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/role-mappings : Get role mappings
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmAvailableGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmAvailableGet(String realm, String orgId, String groupId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/role-mappings/realm/available : Get realm-level roles that can be mapped
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmCompositeGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmCompositeGet(String realm, String orgId, String groupId, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/role-mappings/realm/composite : Get effective realm-level role mappings This will recurse all composite roles to get the result.
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmCompositeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      briefRepresentation - if false, return roles with their attributes (optional, default to true)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmDelete(String realm, String orgId, String groupId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/role-mappings/realm : Delete realm-level role mappings
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Internal Server Error (status code 500)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmGet(String realm, String orgId, String groupId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/role-mappings/realm : Get realm-level role mappings
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmPost(String realm, String orgId, String groupId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/organizations/{org-id}/groups/{group-id}/role-mappings/realm : Add realm-level role mappings to the user
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupId - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Internal Server Error (status code 500)
    • adminRealmsRealmOrganizationsOrgIdGroupsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsPost(String realm, String orgId, @Valid @Valid reactor.core.publisher.Mono<GroupRepresentation> groupRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/organizations/{org-id}/groups : Creates a new top-level group or moves an existing group to top-level Creates a new top-level group in the organization. If the group representation includes an ID, moves the existing organization group to be a top-level group. If no ID is provided, creates a new top-level group.
      Specified by:
      adminRealmsRealmOrganizationsOrgIdGroupsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      groupRepresentation - (optional)
      Returns:
      Created (status code 201) or No Content - Group moved to top-level (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found - Group does not exist (status code 404) or Conflict (status code 409)
    • adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasDelete(String realm, String orgId, String alias)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/organizations/{org-id}/identity-providers/{alias} : Removes the identity provider with the specified alias from the organization Breaks the association between the identity provider and the organization. The provider itself is not deleted. If no provider is found, or if it is not currently associated with the org, an error response is returned
      Specified by:
      adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      alias - (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasGet

      public reactor.core.publisher.Mono<IdentityProviderRepresentation> adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasGet(String realm, String orgId, String alias)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/identity-providers/{alias} : Returns the identity provider associated with the organization that has the specified alias Searches for an identity provider with the given alias. If one is found and is associated with the organization, it is returned. Otherwise, an error response with status NOT_FOUND is returned
      Specified by:
      adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      alias - (required)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasGroupsGet

      public reactor.core.publisher.Flux<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasGroupsGet(String realm, String orgId, String alias, @Valid @Valid Boolean briefRepresentation, @Valid @Valid Boolean exact, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String q, @Valid @Nullable @Valid String search, @Valid @Valid Boolean subGroupsCount)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/identity-providers/{alias}/groups : Returns organization groups for the identity provider Returns organization groups that can be used in identity provider mappers. Only returns groups if the identity provider is associated with the organization.
      Specified by:
      adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasGroupsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      alias - The alias of the identity provider (required)
      briefRepresentation - If true, return brief representation; otherwise return full representation (optional, default to true)
      exact - If true, perform exact match on the search parameter (optional, default to false)
      first - The position of the first result (pagination offset) (optional)
      max - The maximum number of results to return (optional)
      q - A query to search for group attributes, in the format 'key1:value1 key2:value2' (optional)
      search - A string to search for in group names (optional)
      subGroupsCount - If true, include subgroups count in the response (optional, default to false)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmOrganizationsOrgIdIdentityProvidersGet

      public reactor.core.publisher.Flux<IdentityProviderRepresentation> adminRealmsRealmOrganizationsOrgIdIdentityProvidersGet(String realm, String orgId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/identity-providers : Returns all identity providers associated with the organization
      Specified by:
      adminRealmsRealmOrganizationsOrgIdIdentityProvidersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdIdentityProvidersPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdIdentityProvidersPost(String realm, String orgId, @Valid @Valid reactor.core.publisher.Mono<String> body)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/organizations/{org-id}/identity-providers : Adds the identity provider with the specified id to the organization Adds, or associates, an existing identity provider with the organization. If no identity provider is found, or if it is already associated with the organization, an error response is returned
      Specified by:
      adminRealmsRealmOrganizationsOrgIdIdentityProvidersPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      body - Payload should contain only id or alias of the identity provider to be associated with the organization (id or alias with or without quotes). Surrounding whitespace characters will be trimmed. (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Conflict (status code 409)
    • adminRealmsRealmOrganizationsOrgIdInvitationsGet

      public reactor.core.publisher.Flux<OrganizationInvitationRepresentation> adminRealmsRealmOrganizationsOrgIdInvitationsGet(String realm, String orgId, @Valid @Nullable @Valid String email, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid String firstName, @Valid @Nullable @Valid String lastName, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String search, @Valid @Nullable @Valid String status)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/invitations : Get invitations for the organization
      Specified by:
      adminRealmsRealmOrganizationsOrgIdInvitationsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      email - (optional)
      first - (optional)
      firstName - (optional)
      lastName - (optional)
      max - (optional)
      search - (optional)
      status - (optional)
      Returns:
      Success (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdInvitationsIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdInvitationsIdDelete(String realm, String orgId, String id)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/organizations/{org-id}/invitations/{id} : Delete an invitation
      Specified by:
      adminRealmsRealmOrganizationsOrgIdInvitationsIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      id - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmOrganizationsOrgIdInvitationsIdGet

      public reactor.core.publisher.Mono<OrganizationInvitationRepresentation> adminRealmsRealmOrganizationsOrgIdInvitationsIdGet(String realm, String orgId, String id)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/invitations/{id} : Get invitation by ID
      Specified by:
      adminRealmsRealmOrganizationsOrgIdInvitationsIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      id - (required)
      Returns:
      Success (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmOrganizationsOrgIdInvitationsIdResendPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdInvitationsIdResendPost(String realm, String orgId, String id)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/organizations/{org-id}/invitations/{id}/resend : Resend an invitation
      Specified by:
      adminRealmsRealmOrganizationsOrgIdInvitationsIdResendPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      id - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmOrganizationsOrgIdMembersCountGet

      public reactor.core.publisher.Mono<Long> adminRealmsRealmOrganizationsOrgIdMembersCountGet(String realm, String orgId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/members/count : Returns number of members in the organization.
      Specified by:
      adminRealmsRealmOrganizationsOrgIdMembersCountGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdMembersGet

      public reactor.core.publisher.Flux<MemberRepresentation> adminRealmsRealmOrganizationsOrgIdMembersGet(String realm, String orgId, @Valid @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Boolean exact, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String membershipType, @Valid @Nullable @Valid String search)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/members : Returns a paginated list of organization members filtered according to the specified parameters
      Specified by:
      adminRealmsRealmOrganizationsOrgIdMembersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      briefRepresentation - Boolean to return either a brief or a full user representation. If not specified, the brief representation is returned by default. (optional, default to true)
      exact - Boolean which defines whether the param 'search' must match exactly or not (optional)
      first - The position of the first result to be processed (pagination offset) (optional)
      max - The maximum number of results to be returned. Defaults to 10 (optional)
      membershipType - The membership type (optional)
      search - A String representing either a member's username, e-mail, first name, or last name. (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdMembersInviteExistingUserPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdMembersInviteExistingUserPost(String realm, String orgId, @Valid @Valid String id)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/organizations/{org-id}/members/invite-existing-user : Invites an existing user to the organization, using the specified user id
      Specified by:
      adminRealmsRealmOrganizationsOrgIdMembersInviteExistingUserPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      id - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Internal Server Error (status code 500)
    • adminRealmsRealmOrganizationsOrgIdMembersInviteUserPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdMembersInviteUserPost(String realm, String orgId, @Valid @Valid String email, @Valid @Valid String firstName, @Valid @Valid String lastName)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/organizations/{org-id}/members/invite-user : Invites an existing user or sends a registration link to a new user, based on the provided e-mail address. If the user with the given e-mail address exists, it sends an invitation link, otherwise it sends a registration link.
      Specified by:
      adminRealmsRealmOrganizationsOrgIdMembersInviteUserPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      email - (optional)
      firstName - (optional)
      lastName - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Conflict (status code 409) or Internal Server Error (status code 500)
    • adminRealmsRealmOrganizationsOrgIdMembersMemberIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdMembersMemberIdDelete(String realm, String orgId, String memberId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/organizations/{org-id}/members/{member-id} : Removes the user with the specified id from the organization Breaks the association between the user and organization. The user itself is deleted in case the membership is managed, otherwise the user is not deleted. If no user is found, or if they are not a member of the organization, an error response is returned
      Specified by:
      adminRealmsRealmOrganizationsOrgIdMembersMemberIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      memberId - (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdMembersMemberIdGet

      public reactor.core.publisher.Mono<MemberRepresentation> adminRealmsRealmOrganizationsOrgIdMembersMemberIdGet(String realm, String orgId, String memberId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/members/{member-id} : Returns the member of the organization with the specified id Searches for auser with the given id. If one is found, and is currently a member of the organization, returns it. Otherwise,an error response with status NOT_FOUND is returned
      Specified by:
      adminRealmsRealmOrganizationsOrgIdMembersMemberIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      memberId - (required)
      Returns:
      OK (status code 200) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdMembersMemberIdGroupsGet

      public reactor.core.publisher.Flux<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdMembersMemberIdGroupsGet(String realm, String orgId, String memberId, @Valid @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String search)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/members/{member-id}/groups : Returns the organization group memberships for a member with the specified id Searches for auser with the given id. If one is found, and is currently a member of the organization, returns the groups from the organizationwhere the user is member of. Otherwise, an error response with status NOT_FOUND is returned
      Specified by:
      adminRealmsRealmOrganizationsOrgIdMembersMemberIdGroupsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      memberId - (required)
      briefRepresentation - (optional, default to true)
      first - (optional)
      max - (optional)
      search - (optional)
      Returns:
      OK (status code 200) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdMembersMemberIdOrganizationsGet

      public reactor.core.publisher.Flux<OrganizationRepresentation> adminRealmsRealmOrganizationsOrgIdMembersMemberIdOrganizationsGet(String realm, String orgId, String memberId, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/organizations/{org-id}/members/{member-id}/organizations : Returns the organizations associated with the user that has the specified id
      Specified by:
      adminRealmsRealmOrganizationsOrgIdMembersMemberIdOrganizationsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      memberId - (required)
      briefRepresentation - if false, return the full representation. Otherwise, only the basic fields are returned. (optional, default to true)
      Returns:
      OK (status code 200) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmOrganizationsOrgIdMembersPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdMembersPost(String realm, String orgId, @Valid @Valid reactor.core.publisher.Mono<String> body)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/organizations/{org-id}/members : Adds the user with the specified id as a member of the organization Adds, or associates, an existing user with the organization. If no user is found, or if it is already associated with the organization, an error response is returned
      Specified by:
      adminRealmsRealmOrganizationsOrgIdMembersPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      body - Payload should contain only id of the user to be added to the organization (UUID with or without quotes). Surrounding whitespace characters will be trimmed. (required)
      Returns:
      Created (status code 201) or Bad Request (status code 400) or Forbidden (status code 403) or Conflict (status code 409)
    • adminRealmsRealmOrganizationsOrgIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsOrgIdPut(String realm, String orgId, @Valid @Valid reactor.core.publisher.Mono<OrganizationRepresentation> organizationRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/organizations/{org-id} : Updates the organization
      Specified by:
      adminRealmsRealmOrganizationsOrgIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      orgId - (required)
      organizationRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Conflict (status code 409)
    • adminRealmsRealmOrganizationsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmOrganizationsPost(String realm, @Valid @Valid reactor.core.publisher.Mono<OrganizationRepresentation> organizationRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/organizations : Creates a new organization
      Specified by:
      adminRealmsRealmOrganizationsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      organizationRepresentation - (optional)
      Returns:
      Created (status code 201) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmPartialExportPost

      public reactor.core.publisher.Mono<RealmRepresentation> adminRealmsRealmPartialExportPost(String realm, @Valid @Nullable @Valid Boolean exportClients, @Valid @Nullable @Valid Boolean exportGroupsAndRoles)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/partial-export : Partial export of existing realm into a JSON file.
      Specified by:
      adminRealmsRealmPartialExportPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      exportClients - (optional)
      exportGroupsAndRoles - (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmPartialImportPost

      public reactor.core.publisher.Mono<Object> adminRealmsRealmPartialImportPost(String realm, @Valid @Valid reactor.core.publisher.Mono<org.springframework.core.io.Resource> body)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/partialImport : Partial import from a JSON file to an existing realm.
      Specified by:
      adminRealmsRealmPartialImportPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      body - (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403) or Conflict (status code 409)
    • adminRealmsRealmPushRevocationPost

      public reactor.core.publisher.Mono<GlobalRequestResult> adminRealmsRealmPushRevocationPost(String realm)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/push-revocation : Push the realm's revocation policy to any client that has an admin url associated with it.
      Specified by:
      adminRealmsRealmPushRevocationPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmPut(String realm, @Valid @Valid reactor.core.publisher.Mono<RealmRepresentation> realmRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm} : Update the top-level information of the realm Any user, roles or client information in the representation will be ignored. This will only update top-level attributes of the realm.
      Specified by:
      adminRealmsRealmPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      realmRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Conflict (status code 409) or Internal Server Error (status code 500)
    • adminRealmsRealmRolesByIdRoleIdCompositesClientsClientUuidGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmRolesByIdRoleIdCompositesClientsClientUuidGet(String realm, String clientUuid, String roleId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles-by-id/{role-id}/composites/clients/{clientUuid} : Get client-level roles for the client that are in the role's composite
      Specified by:
      adminRealmsRealmRolesByIdRoleIdCompositesClientsClientUuidGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      clientUuid - (required)
      roleId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmRolesByIdRoleIdCompositesDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmRolesByIdRoleIdCompositesDelete(String realm, String roleId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/roles-by-id/{role-id}/composites : Remove a set of roles from the role's composite
      Specified by:
      adminRealmsRealmRolesByIdRoleIdCompositesDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleId - Role id (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Forbidden (status code 403)
    • adminRealmsRealmRolesByIdRoleIdCompositesGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmRolesByIdRoleIdCompositesGet(String realm, String roleId, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String search)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles-by-id/{role-id}/composites : Get role's children Returns a set of role's children provided the role is a composite.
      Specified by:
      adminRealmsRealmRolesByIdRoleIdCompositesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleId - (required)
      first - (optional)
      max - (optional)
      search - (optional)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmRolesByIdRoleIdCompositesPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmRolesByIdRoleIdCompositesPost(String realm, String roleId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/roles-by-id/{role-id}/composites : Make the role a composite role by associating some child roles
      Specified by:
      adminRealmsRealmRolesByIdRoleIdCompositesPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleId - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Forbidden (status code 403)
    • adminRealmsRealmRolesByIdRoleIdCompositesRealmGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmRolesByIdRoleIdCompositesRealmGet(String realm, String roleId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles-by-id/{role-id}/composites/realm : Get realm-level roles that are in the role's composite
      Specified by:
      adminRealmsRealmRolesByIdRoleIdCompositesRealmGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmRolesByIdRoleIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmRolesByIdRoleIdDelete(String realm, String roleId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/roles-by-id/{role-id} : Delete the role
      Specified by:
      adminRealmsRealmRolesByIdRoleIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleId - id of role (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmRolesByIdRoleIdGet

      public reactor.core.publisher.Mono<RoleRepresentation> adminRealmsRealmRolesByIdRoleIdGet(String realm, String roleId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles-by-id/{role-id} : Get a specific role's representation
      Specified by:
      adminRealmsRealmRolesByIdRoleIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleId - id of role (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmRolesByIdRoleIdManagementPermissionsGet

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmRolesByIdRoleIdManagementPermissionsGet(String realm, String roleId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles-by-id/{role-id}/management/permissions : Return object stating whether role Authorization permissions have been initialized or not and a reference
      Specified by:
      adminRealmsRealmRolesByIdRoleIdManagementPermissionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmRolesByIdRoleIdManagementPermissionsPut

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmRolesByIdRoleIdManagementPermissionsPut(String realm, String roleId, @Valid @Valid reactor.core.publisher.Mono<ManagementPermissionReference> managementPermissionReference)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/roles-by-id/{role-id}/management/permissions : Return object stating whether role Authorization permissions have been initialized or not and a reference
      Specified by:
      adminRealmsRealmRolesByIdRoleIdManagementPermissionsPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleId - (required)
      managementPermissionReference - (optional)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmRolesByIdRoleIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmRolesByIdRoleIdPut(String realm, String roleId, @Valid @Valid reactor.core.publisher.Mono<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/roles-by-id/{role-id} : Update the role
      Specified by:
      adminRealmsRealmRolesByIdRoleIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleId - id of role (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmRolesGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmRolesGet(String realm, @Valid @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Valid String search)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles : Get all roles for the realm or client
      Specified by:
      adminRealmsRealmRolesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      briefRepresentation - (optional, default to true)
      first - (optional)
      max - (optional)
      search - (optional, default to )
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmRolesPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmRolesPost(String realm, @Valid @Valid reactor.core.publisher.Mono<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/roles : Create a new role for the realm or client
      Specified by:
      adminRealmsRealmRolesPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleRepresentation - (optional)
      Returns:
      Created (status code 201) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Conflict (status code 409) or Internal Server Error (status code 500)
    • adminRealmsRealmRolesRoleNameCompositesClientsTargetClientUuidGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmRolesRoleNameCompositesClientsTargetClientUuidGet(String realm, String roleName, String targetClientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles/{role-name}/composites/clients/{targetClientUuid} : Get client-level roles for the client that are in the role's composite
      Specified by:
      adminRealmsRealmRolesRoleNameCompositesClientsTargetClientUuidGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleName - role's name (not id!) (required)
      targetClientUuid - (required)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmRolesRoleNameCompositesDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmRolesRoleNameCompositesDelete(String realm, String roleName, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/roles/{role-name}/composites : Remove roles from the role's composite
      Specified by:
      adminRealmsRealmRolesRoleNameCompositesDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleName - role's name (not id!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmRolesRoleNameCompositesGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmRolesRoleNameCompositesGet(String realm, String roleName)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles/{role-name}/composites : Get composites of the role
      Specified by:
      adminRealmsRealmRolesRoleNameCompositesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleName - role's name (not id!) (required)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmRolesRoleNameCompositesPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmRolesRoleNameCompositesPost(String realm, String roleName, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/roles/{role-name}/composites : Add a composite to the role
      Specified by:
      adminRealmsRealmRolesRoleNameCompositesPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleName - role's name (not id!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmRolesRoleNameCompositesRealmGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmRolesRoleNameCompositesRealmGet(String realm, String roleName)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles/{role-name}/composites/realm : Get realm-level roles of the role's composite
      Specified by:
      adminRealmsRealmRolesRoleNameCompositesRealmGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleName - role's name (not id!) (required)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmRolesRoleNameDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmRolesRoleNameDelete(String realm, String roleName)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/roles/{role-name} : Delete a role by name
      Specified by:
      adminRealmsRealmRolesRoleNameDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleName - role's name (not id!) (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmRolesRoleNameGet

      public reactor.core.publisher.Mono<RoleRepresentation> adminRealmsRealmRolesRoleNameGet(String realm, String roleName)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles/{role-name} : Get a role by name
      Specified by:
      adminRealmsRealmRolesRoleNameGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleName - role's name (not id!) (required)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmRolesRoleNameGroupsGet

      public reactor.core.publisher.Flux<UserRepresentation> adminRealmsRealmRolesRoleNameGroupsGet(String realm, String roleName, @Valid @Nullable @Valid Integer max, @Valid @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Integer first)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles/{role-name}/groups : Returns a stream of groups that have the specified role name
      Specified by:
      adminRealmsRealmRolesRoleNameGroupsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleName - the role name. (required)
      max - Maximum number of results to return. Unbounded if negative. (optional)
      briefRepresentation - If false, return a full representation of the GroupRepresentation objects. (optional, default to true)
      first - First result to return. Ignored if negative or null. (optional)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmRolesRoleNameManagementPermissionsGet

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmRolesRoleNameManagementPermissionsGet(String realm, String roleName)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles/{role-name}/management/permissions : Return object stating whether role Authorization permissions have been initialized or not and a reference
      Specified by:
      adminRealmsRealmRolesRoleNameManagementPermissionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleName - (required)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmRolesRoleNameManagementPermissionsPut

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmRolesRoleNameManagementPermissionsPut(String realm, String roleName, @Valid @Valid reactor.core.publisher.Mono<ManagementPermissionReference> managementPermissionReference)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/roles/{role-name}/management/permissions : Return object stating whether role Authorization permissions have been initialized or not and a reference
      Specified by:
      adminRealmsRealmRolesRoleNameManagementPermissionsPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleName - (required)
      managementPermissionReference - (optional)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmRolesRoleNamePut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmRolesRoleNamePut(String realm, String roleName, @Valid @Valid reactor.core.publisher.Mono<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/roles/{role-name} : Update a role by name
      Specified by:
      adminRealmsRealmRolesRoleNamePut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleName - role's name (not id!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Conflict (status code 409)
    • adminRealmsRealmRolesRoleNameUsersGet

      public reactor.core.publisher.Flux<UserRepresentation> adminRealmsRealmRolesRoleNameUsersGet(String realm, String roleName, @Valid @Nullable @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/roles/{role-name}/users : Returns a stream of users that have the specified role name.
      Specified by:
      adminRealmsRealmRolesRoleNameUsersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      roleName - the role name. (required)
      briefRepresentation - Boolean which defines whether brief representations are returned (default: false) (optional)
      first - first result to return. Ignored if negative or null. (optional)
      max - Maximum number of results to return. Unbounded if negative. (optional)
      Returns:
      (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmSessionsSessionDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmSessionsSessionDelete(String realm, String session, @Valid @Valid Boolean isOffline)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/sessions/{session} : Remove a specific user session. Any client that has an admin url will also be told to invalidate this particular session.
      Specified by:
      adminRealmsRealmSessionsSessionDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      session - (required)
      isOffline - (optional, default to false)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmUsersCountGet

      public reactor.core.publisher.Mono<Integer> adminRealmsRealmUsersCountGet(String realm, @Valid @Nullable @Valid String createdAfter, @Valid @Nullable @Valid String createdBefore, @Valid @Nullable @Valid String email, @Valid @Nullable @Valid Boolean emailVerified, @Valid @Nullable @Valid Boolean enabled, @Valid @Nullable @Valid Boolean exact, @Valid @Nullable @Valid String firstName, @Valid @Nullable @Valid String idpAlias, @Valid @Nullable @Valid String idpUserId, @Valid @Nullable @Valid String lastName, @Valid @Nullable @Valid String q, @Valid @Nullable @Valid String search, @Valid @Nullable @Valid String username)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/count : Returns the number of users that match the given criteria. It can be called in three different ways. 1. Don’t specify any criteria and pass null. The number of all users within that realm will be returned. <p> 2. If search is specified other criteria such as last will be ignored even though you set them. The search string will be matched against the first and last name, the username and the email of a user. <p> 3. If search is unspecified but any of last, first, email or username those criteria are matched against their respective fields on a user entity. Combined with a logical and.
      Specified by:
      adminRealmsRealmUsersCountGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      createdAfter - Only return users created after (inclusive) the given date, in ISO-8601 format (yyyy-MM-dd) or epoch milliseconds (optional)
      createdBefore - Only return users created before (inclusive) the given date, in ISO-8601 format (yyyy-MM-dd) or epoch milliseconds (optional)
      email - A String contained in email, or the complete email, if param \"exact\" is true (optional)
      emailVerified - whether the email has been verified (optional)
      enabled - Boolean representing if user is enabled or not (optional)
      exact - Boolean which defines whether the params \"last\", \"first\", \"email\" and \"username\" must match exactly (optional)
      firstName - A String contained in firstName, or the complete firstName, if param \"exact\" is true (optional)
      idpAlias - The alias of an Identity Provider linked to the user (optional)
      idpUserId - The userId at an Identity Provider linked to the user (optional)
      lastName - A String contained in lastName, or the complete lastName, if param \"exact\" is true (optional)
      q - A query to search for custom attributes, in the format 'key1:value2 key2:value2' (optional)
      search - A String contained in username, first or last name, or email. Default search behavior is prefix-based (e.g., foo or foo*). Use *foo* for infix search and \"foo\" for exact search. (optional)
      username - A String contained in username, or the complete username, if param \"exact\" is true (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersGet

      public reactor.core.publisher.Flux<UserRepresentation> adminRealmsRealmUsersGet(String realm, @Valid @Nullable @Valid Boolean briefRepresentation, @Valid @Nullable @Valid String createdAfter, @Valid @Nullable @Valid String createdBefore, @Valid @Nullable @Valid String email, @Valid @Nullable @Valid Boolean emailVerified, @Valid @Nullable @Valid Boolean enabled, @Valid @Nullable @Valid Boolean exact, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid String firstName, @Valid @Nullable @Valid String idpAlias, @Valid @Nullable @Valid String idpUserId, @Valid @Nullable @Valid String lastName, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String q, @Valid @Nullable @Valid String search, @Valid @Nullable @Valid String username)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users : Get users Returns a stream of users, filtered according to query parameters. Returns a stream of users. Note that the 'credentials' field in the returned UserRepresentation objects is typically not populated for performance reasons. If specific credential metadata is required, use the dedicated 'GET /admin/realms/{realm}/users/{user-id}/credentials' endpoint.
      Specified by:
      adminRealmsRealmUsersGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      briefRepresentation - Boolean which defines whether brief representations are returned (default: false) (optional)
      createdAfter - Only return users created after (inclusive) the given date, in ISO-8601 format (yyyy-MM-dd) or epoch milliseconds (optional)
      createdBefore - Only return users created before (inclusive) the given date, in ISO-8601 format (yyyy-MM-dd) or epoch milliseconds (optional)
      email - A String contained in email, or the complete email, if param \"exact\" is true (optional)
      emailVerified - whether the email has been verified (optional)
      enabled - Boolean representing if user is enabled or not (optional)
      exact - Boolean which defines whether the params \"last\", \"first\", \"email\" and \"username\" must match exactly (optional)
      first - Pagination offset (optional)
      firstName - A String contained in firstName, or the complete firstName, if param \"exact\" is true (optional)
      idpAlias - The alias of an Identity Provider linked to the user (optional)
      idpUserId - The userId at an Identity Provider linked to the user (optional)
      lastName - A String contained in lastName, or the complete lastName, if param \"exact\" is true (optional)
      max - Maximum results size (defaults to 100) (optional)
      q - A query to search for custom attributes, in the format 'key1:value2 key2:value2' (optional)
      search - A String contained in username, first or last name, or email. Default search behavior is prefix-based (e.g., foo or foo*). Use *foo* for infix search and \"foo\" for exact search. (optional)
      username - A String contained in username, or the complete username, if param \"exact\" is true (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersManagementPermissionsGet

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmUsersManagementPermissionsGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users-management-permissions
      Specified by:
      adminRealmsRealmUsersManagementPermissionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersManagementPermissionsPut

      public reactor.core.publisher.Mono<ManagementPermissionReference> adminRealmsRealmUsersManagementPermissionsPut(String realm, @Valid @Valid reactor.core.publisher.Mono<ManagementPermissionReference> managementPermissionReference)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/users-management-permissions
      Specified by:
      adminRealmsRealmUsersManagementPermissionsPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      managementPermissionReference - (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersPost(String realm, @Valid @Valid reactor.core.publisher.Mono<UserRepresentation> userRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/users : Create a new user Username must be unique.
      Specified by:
      adminRealmsRealmUsersPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userRepresentation - (optional)
      Returns:
      Created (status code 201) or Bad Request (status code 400) or Forbidden (status code 403) or Conflict (status code 409) or Internal Server Error (status code 500)
    • adminRealmsRealmUsersProfileGet

      public reactor.core.publisher.Mono<UPConfig> adminRealmsRealmUsersProfileGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/profile Get the configuration for the user profile
      Specified by:
      adminRealmsRealmUsersProfileGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersProfileMetadataGet

      public reactor.core.publisher.Mono<UserProfileMetadata> adminRealmsRealmUsersProfileMetadataGet(String realm)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/profile/metadata Get the UserProfileMetadata from the configuration
      Specified by:
      adminRealmsRealmUsersProfileMetadataGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersProfilePut

      public reactor.core.publisher.Mono<UPConfig> adminRealmsRealmUsersProfilePut(String realm, @Valid @Valid reactor.core.publisher.Mono<UPConfig> upConfig)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/users/profile Set the configuration for the user profile
      Specified by:
      adminRealmsRealmUsersProfilePut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      upConfig - (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdConfiguredUserStorageCredentialTypesGet

      public reactor.core.publisher.Mono<List<String>> adminRealmsRealmUsersUserIdConfiguredUserStorageCredentialTypesGet(String realm, String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/configured-user-storage-credential-types : Return credential types, which are provided by the user storage where user is stored. Returned values can contain for example \"password\", \"otp\" etc. This will always return empty list for \"local\" users, which are not backed by any user storage
      Specified by:
      adminRealmsRealmUsersUserIdConfiguredUserStorageCredentialTypesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdConsentsClientDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdConsentsClientDelete(String realm, String userId, String client)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/users/{user-id}/consents/{client} : Revoke consent and offline tokens for particular client from user
      Specified by:
      adminRealmsRealmUsersUserIdConsentsClientDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      client - Client id (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmUsersUserIdConsentsGet

      public reactor.core.publisher.Flux<Map<String,Object>> adminRealmsRealmUsersUserIdConsentsGet(String realm, String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/consents : Get consents granted by the user
      Specified by:
      adminRealmsRealmUsersUserIdConsentsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdCredentialsCredentialIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdCredentialsCredentialIdDelete(String realm, String userId, String credentialId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/users/{user-id}/credentials/{credentialId} : Remove a credential for a user
      Specified by:
      adminRealmsRealmUsersUserIdCredentialsCredentialIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      credentialId - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmUsersUserIdCredentialsCredentialIdMoveAfterNewPreviousCredentialIdPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdCredentialsCredentialIdMoveAfterNewPreviousCredentialIdPost(String realm, String userId, String credentialId, String newPreviousCredentialId)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/users/{user-id}/credentials/{credentialId}/moveAfter/{newPreviousCredentialId} : Move a credential to a position behind another credential
      Specified by:
      adminRealmsRealmUsersUserIdCredentialsCredentialIdMoveAfterNewPreviousCredentialIdPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      credentialId - The credential to move (required)
      newPreviousCredentialId - The credential that will be the previous element in the list. If set to null, the moved credential will be the first element in the list. (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmUsersUserIdCredentialsCredentialIdMoveToFirstPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdCredentialsCredentialIdMoveToFirstPost(String realm, String userId, String credentialId)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/users/{user-id}/credentials/{credentialId}/moveToFirst : Move a credential to a first position in the credentials list of the user
      Specified by:
      adminRealmsRealmUsersUserIdCredentialsCredentialIdMoveToFirstPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      credentialId - The credential to move (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmUsersUserIdCredentialsCredentialIdUserLabelPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdCredentialsCredentialIdUserLabelPut(String realm, String userId, String credentialId, @Valid @Valid reactor.core.publisher.Mono<String> body)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/users/{user-id}/credentials/{credentialId}/userLabel : Update a credential label for a user
      Specified by:
      adminRealmsRealmUsersUserIdCredentialsCredentialIdUserLabelPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      credentialId - (required)
      body - (optional)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmUsersUserIdCredentialsGet

      public reactor.core.publisher.Flux<CredentialRepresentation> adminRealmsRealmUsersUserIdCredentialsGet(String realm, String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/credentials
      Specified by:
      adminRealmsRealmUsersUserIdCredentialsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdDelete(String realm, String userId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/users/{user-id} : Delete the user
      Specified by:
      adminRealmsRealmUsersUserIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdDisableCredentialTypesPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdDisableCredentialTypesPut(String realm, String userId, @Valid @Valid reactor.core.publisher.Flux<String> requestBody)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/users/{user-id}/disable-credential-types : Disable all credentials for a user of a specific type
      Specified by:
      adminRealmsRealmUsersUserIdDisableCredentialTypesPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      requestBody - (optional)
      Returns:
      No Content (status code 204) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdExecuteActionsEmailPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdExecuteActionsEmailPut(String realm, String userId, @Valid @Nullable @Valid String clientId, @Valid @Nullable @Valid Integer lifespan, @Valid @Nullable @Valid String redirectUri, @Valid @Valid reactor.core.publisher.Flux<String> requestBody)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/users/{user-id}/execute-actions-email : Send an email to the user with a link they can click to execute particular actions. An email contains a link the user can click to perform a set of required actions. The redirectUri and clientId parameters are optional. If no redirect is given, then there will be no link back to click after actions have completed. Redirect uri must be a valid uri for the particular clientId.
      Specified by:
      adminRealmsRealmUsersUserIdExecuteActionsEmailPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      clientId - Client id (optional)
      lifespan - Number of seconds after which the generated token expires (optional)
      redirectUri - Redirect uri (optional)
      requestBody - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Internal Server Error (status code 500)
    • adminRealmsRealmUsersUserIdFederatedIdentityGet

      public reactor.core.publisher.Flux<FederatedIdentityRepresentation> adminRealmsRealmUsersUserIdFederatedIdentityGet(String realm, String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/federated-identity : Get social logins associated with the user
      Specified by:
      adminRealmsRealmUsersUserIdFederatedIdentityGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdFederatedIdentityProviderDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdFederatedIdentityProviderDelete(String realm, String userId, String provider)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/users/{user-id}/federated-identity/{provider} : Remove a social login provider from user
      Specified by:
      adminRealmsRealmUsersUserIdFederatedIdentityProviderDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      provider - Social login provider id (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmUsersUserIdFederatedIdentityProviderPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdFederatedIdentityProviderPost(String realm, String userId, String provider, @Valid @Valid reactor.core.publisher.Mono<FederatedIdentityRepresentation> federatedIdentityRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/users/{user-id}/federated-identity/{provider} : Add a social login provider to the user
      Specified by:
      adminRealmsRealmUsersUserIdFederatedIdentityProviderPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      provider - Social login provider id (required)
      federatedIdentityRepresentation - (optional)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Conflict (status code 409)
    • adminRealmsRealmUsersUserIdGet

      public reactor.core.publisher.Mono<UserRepresentation> adminRealmsRealmUsersUserIdGet(String realm, String userId, @Valid @Nullable @Valid Boolean userProfileMetadata)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id} : Get representation of the user
      Specified by:
      adminRealmsRealmUsersUserIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      userProfileMetadata - Indicates if the user profile metadata should be added to the response (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdGroupsCountGet

      public reactor.core.publisher.Mono<Map<String,Long>> adminRealmsRealmUsersUserIdGroupsCountGet(String realm, String userId, @Valid @Nullable @Valid String search)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/groups/count
      Specified by:
      adminRealmsRealmUsersUserIdGroupsCountGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      search - (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdGroupsGet

      public reactor.core.publisher.Flux<GroupRepresentation> adminRealmsRealmUsersUserIdGroupsGet(String realm, String userId, @Valid @Valid Boolean briefRepresentation, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String search)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/groups
      Specified by:
      adminRealmsRealmUsersUserIdGroupsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      briefRepresentation - (optional, default to true)
      first - (optional)
      max - (optional)
      search - (optional)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdGroupsGroupIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdGroupsGroupIdDelete(String realm, String userId, String groupId)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/users/{user-id}/groups/{groupId}
      Specified by:
      adminRealmsRealmUsersUserIdGroupsGroupIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      groupId - (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Internal Server Error (status code 500)
    • adminRealmsRealmUsersUserIdGroupsGroupIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdGroupsGroupIdPut(String realm, String userId, String groupId)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/users/{user-id}/groups/{groupId}
      Specified by:
      adminRealmsRealmUsersUserIdGroupsGroupIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      groupId - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmUsersUserIdImpersonationPost

      public reactor.core.publisher.Mono<Map<String,Object>> adminRealmsRealmUsersUserIdImpersonationPost(String realm, String userId)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/users/{user-id}/impersonation : Impersonate the user
      Specified by:
      adminRealmsRealmUsersUserIdImpersonationPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      OK (status code 200) or Bad Request (status code 400) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdLogoutPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdLogoutPost(String realm, String userId)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/users/{user-id}/logout : Remove all user sessions associated with the user Also send notification to all clients that have an admin URL to invalidate the sessions for the particular user.
      Specified by:
      adminRealmsRealmUsersUserIdLogoutPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      No Content (status code 204) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdOfflineSessionsClientUuidGet

      public reactor.core.publisher.Flux<UserSessionRepresentation> adminRealmsRealmUsersUserIdOfflineSessionsClientUuidGet(String realm, String userId, String clientUuid)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/offline-sessions/{clientUuid} : Get offline sessions associated with the user and client
      Specified by:
      adminRealmsRealmUsersUserIdOfflineSessionsClientUuidGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      clientUuid - (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403) or Not Found (status code 404)
    • adminRealmsRealmUsersUserIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdPut(String realm, String userId, @Valid @Valid reactor.core.publisher.Mono<UserRepresentation> userRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/users/{user-id} : Update the user
      Specified by:
      adminRealmsRealmUsersUserIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      userRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Conflict (status code 409) or Internal Server Error (status code 500)
    • adminRealmsRealmUsersUserIdResetPasswordEmailPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdResetPasswordEmailPut(String realm, String userId, @Valid @Nullable @Valid String clientId, @Valid @Nullable @Valid String redirectUri)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/users/{user-id}/reset-password-email : Send an email to the user with a link they can click to reset their password. The redirectUri and clientId parameters are optional. The default for the redirect is the account client. This endpoint has been deprecated. Please use the execute-actions-email passing a list with UPDATE_PASSWORD within it.
      Specified by:
      adminRealmsRealmUsersUserIdResetPasswordEmailPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      clientId - client id (optional)
      redirectUri - redirect uri (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Internal Server Error (status code 500)
    • adminRealmsRealmUsersUserIdResetPasswordPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdResetPasswordPut(String realm, String userId, @Valid @Valid reactor.core.publisher.Mono<CredentialRepresentation> credentialRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/users/{user-id}/reset-password : Set up a new password for the user.
      Specified by:
      adminRealmsRealmUsersUserIdResetPasswordPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      credentialRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Internal Server Error (status code 500)
    • adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdAvailableGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdAvailableGet(String realm, String userId, String clientId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/role-mappings/clients/{client-id}/available : Get available client-level roles that can be mapped to the user or group
      Specified by:
      adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      clientId - client id (not clientId!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdCompositeGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdCompositeGet(String realm, String userId, String clientId, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/role-mappings/clients/{client-id}/composite : Get effective client-level role mappings This recurses any composite roles
      Specified by:
      adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdCompositeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      clientId - client id (not clientId!) (required)
      briefRepresentation - if false, return roles with their attributes (optional, default to true)
      Returns:
      OK (status code 200)
    • adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdDelete(String realm, String userId, String clientId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/users/{user-id}/role-mappings/clients/{client-id} : Delete client-level roles from user or group role mapping
      Specified by:
      adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      clientId - client id (not clientId!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdGet(String realm, String userId, String clientId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/role-mappings/clients/{client-id} : Get client-level role mappings for the user or group, and the app
      Specified by:
      adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      clientId - client id (not clientId!) (required)
      Returns:
      OK (status code 200)
    • adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdPost(String realm, String userId, String clientId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/users/{user-id}/role-mappings/clients/{client-id} : Add client-level roles to the user or group role mapping
      Specified by:
      adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      clientId - client id (not clientId!) (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204)
    • adminRealmsRealmUsersUserIdRoleMappingsGet

      public reactor.core.publisher.Mono<MappingsRepresentation> adminRealmsRealmUsersUserIdRoleMappingsGet(String realm, String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/role-mappings : Get role mappings
      Specified by:
      adminRealmsRealmUsersUserIdRoleMappingsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdRoleMappingsRealmAvailableGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsRealmAvailableGet(String realm, String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/role-mappings/realm/available : Get realm-level roles that can be mapped
      Specified by:
      adminRealmsRealmUsersUserIdRoleMappingsRealmAvailableGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdRoleMappingsRealmCompositeGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsRealmCompositeGet(String realm, String userId, @Valid @Valid Boolean briefRepresentation)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/role-mappings/realm/composite : Get effective realm-level role mappings This will recurse all composite roles to get the result.
      Specified by:
      adminRealmsRealmUsersUserIdRoleMappingsRealmCompositeGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      briefRepresentation - if false, return roles with their attributes (optional, default to true)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdRoleMappingsRealmDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdRoleMappingsRealmDelete(String realm, String userId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/users/{user-id}/role-mappings/realm : Delete realm-level role mappings
      Specified by:
      adminRealmsRealmUsersUserIdRoleMappingsRealmDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Internal Server Error (status code 500)
    • adminRealmsRealmUsersUserIdRoleMappingsRealmGet

      public reactor.core.publisher.Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsRealmGet(String realm, String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/role-mappings/realm : Get realm-level role mappings
      Specified by:
      adminRealmsRealmUsersUserIdRoleMappingsRealmGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdRoleMappingsRealmPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdRoleMappingsRealmPost(String realm, String userId, @Valid @Valid reactor.core.publisher.Flux<RoleRepresentation> roleRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/users/{user-id}/role-mappings/realm : Add realm-level role mappings to the user
      Specified by:
      adminRealmsRealmUsersUserIdRoleMappingsRealmPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      roleRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Not Found (status code 404) or Internal Server Error (status code 500)
    • adminRealmsRealmUsersUserIdSendVerifyEmailPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmUsersUserIdSendVerifyEmailPut(String realm, String userId, @Valid @Nullable @Valid String clientId, @Valid @Nullable @Valid Integer lifespan, @Valid @Nullable @Valid String redirectUri)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/users/{user-id}/send-verify-email : Send an email-verification email to the user An email contains a link the user can click to verify their email address. The redirectUri, clientId and lifespan parameters are optional. The default for the redirect is the account client. The default for the lifespan is 12 hours
      Specified by:
      adminRealmsRealmUsersUserIdSendVerifyEmailPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      clientId - Client id (optional)
      lifespan - Number of seconds after which the generated token expires (optional)
      redirectUri - Redirect uri (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400) or Forbidden (status code 403) or Internal Server Error (status code 500)
    • adminRealmsRealmUsersUserIdSessionsGet

      public reactor.core.publisher.Flux<UserSessionRepresentation> adminRealmsRealmUsersUserIdSessionsGet(String realm, String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/sessions : Get sessions associated with the user
      Specified by:
      adminRealmsRealmUsersUserIdSessionsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmUsersUserIdUnmanagedAttributesGet

      public reactor.core.publisher.Mono<Map<String,List<String>>> adminRealmsRealmUsersUserIdUnmanagedAttributesGet(String realm, String userId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/users/{user-id}/unmanagedAttributes
      Specified by:
      adminRealmsRealmUsersUserIdUnmanagedAttributesGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      userId - (required)
      Returns:
      OK (status code 200) or Forbidden (status code 403)
    • adminRealmsRealmWorkflowsGet

      public reactor.core.publisher.Mono<WorkflowRepresentation> adminRealmsRealmWorkflowsGet(String realm, @Valid @Nullable @Valid Boolean exact, @Valid @Nullable @Valid Integer first, @Valid @Nullable @Valid Integer max, @Valid @Nullable @Valid String search)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/workflows : List workflows List workflows filtered by name and paginated using first and max parameters.
      Specified by:
      adminRealmsRealmWorkflowsGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      exact - Boolean which defines whether the param 'search' must match exactly or not (optional)
      first - The position of the first result to be processed (pagination offset) (optional)
      max - The maximum number of results to be returned - defaults to 10 (optional)
      search - A String representing the workflow name - either partial or exact (optional)
      Returns:
      OK (status code 200) or Bad Request (status code 400)
    • adminRealmsRealmWorkflowsIdActivateTypeResourceIdPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmWorkflowsIdActivateTypeResourceIdPost(String realm, String id, String resourceId, Object type, @Valid @Nullable @Valid String notBefore)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/workflows/{id}/activate/{type}/{resourceId} : Activate workflow for resource Activate the workflow for the given resource type and identifier. Optionally schedule the first step using the notBefore parameter.
      Specified by:
      adminRealmsRealmWorkflowsIdActivateTypeResourceIdPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - Workflow identifier (required)
      resourceId - Resource identifier (required)
      type - Resource type (required)
      notBefore - Optional value representing the time to schedule the first workflow step. The value is either an integer representing the seconds from now, an integer followed by 'ms' representing milliseconds from now, or an ISO-8601 date string. (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400)
    • adminRealmsRealmWorkflowsIdDeactivateTypeResourceIdPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmWorkflowsIdDeactivateTypeResourceIdPost(String realm, String id, String resourceId, Object type)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/workflows/{id}/deactivate/{type}/{resourceId} : Deactivate workflow for resource Deactivate the workflow for the given resource type and identifier.
      Specified by:
      adminRealmsRealmWorkflowsIdDeactivateTypeResourceIdPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - Workflow identifier (required)
      resourceId - Resource identifier (required)
      type - Resource type (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400)
    • adminRealmsRealmWorkflowsIdDelete

      public reactor.core.publisher.Mono<Void> adminRealmsRealmWorkflowsIdDelete(String realm, String id)
      Description copied from interface: AdminApi
      DELETE /admin/realms/{realm}/workflows/{id} : Delete workflow Delete the workflow and its configuration.
      Specified by:
      adminRealmsRealmWorkflowsIdDelete in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - Workflow identifier (required)
      Returns:
      No Content (status code 204) or Bad Request (status code 400)
    • adminRealmsRealmWorkflowsIdGet

      public reactor.core.publisher.Mono<WorkflowRepresentation> adminRealmsRealmWorkflowsIdGet(String realm, String id, @Valid @Nullable @Valid Boolean includeId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/workflows/{id} : Get workflow Get the workflow representation. Optionally exclude the workflow id from the response.
      Specified by:
      adminRealmsRealmWorkflowsIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - Workflow identifier (required)
      includeId - Indicates whether the workflow and step ids should be included in the representation or not - defaults to true (optional)
      Returns:
      OK (status code 200) or Bad Request (status code 400)
    • adminRealmsRealmWorkflowsIdPut

      public reactor.core.publisher.Mono<Void> adminRealmsRealmWorkflowsIdPut(String realm, String id, @Valid @Valid reactor.core.publisher.Mono<WorkflowRepresentation> workflowRepresentation)
      Description copied from interface: AdminApi
      PUT /admin/realms/{realm}/workflows/{id} : Update workflow Update the workflow configuration. This method does not update the workflow steps.
      Specified by:
      adminRealmsRealmWorkflowsIdPut in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      id - Workflow identifier (required)
      workflowRepresentation - (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400)
    • adminRealmsRealmWorkflowsMigratePost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmWorkflowsMigratePost(String realm, @Valid @Nullable @Valid String from, @Valid @Nullable @Valid String to)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/workflows/migrate : Migrate scheduled resources from one step to another Migrate scheduled resources from one step to another step in the same or in a different workflow.
      Specified by:
      adminRealmsRealmWorkflowsMigratePost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      from - A String representing the id of the step to migrate from (optional)
      to - A String representing the id of the step to migrate to (optional)
      Returns:
      No Content (status code 204) or Bad Request (status code 400)
    • adminRealmsRealmWorkflowsPost

      public reactor.core.publisher.Mono<Void> adminRealmsRealmWorkflowsPost(String realm, @Valid @Valid reactor.core.publisher.Mono<WorkflowRepresentation> workflowRepresentation)
      Description copied from interface: AdminApi
      POST /admin/realms/{realm}/workflows : Create workflow Create a new workflow from the provided representation.
      Specified by:
      adminRealmsRealmWorkflowsPost in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      workflowRepresentation - (optional)
      Returns:
      Created (status code 201) or Bad Request (status code 400)
    • adminRealmsRealmWorkflowsScheduledResourceIdGet

      public reactor.core.publisher.Mono<WorkflowRepresentation> adminRealmsRealmWorkflowsScheduledResourceIdGet(String realm, String resourceId)
      Description copied from interface: AdminApi
      GET /admin/realms/{realm}/workflows/scheduled/{resource-id} : List scheduled workflows for resource Return workflows that have scheduled steps for the given resource identifier.
      Specified by:
      adminRealmsRealmWorkflowsScheduledResourceIdGet in interface AdminApi
      Parameters:
      realm - realm name (not id!) (required)
      resourceId - Identifier of the resource associated with the scheduled workflows (required)
      Returns:
      OK (status code 200) or Bad Request (status code 400)