/*
    * Copyright 2026 the original author or authors.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.bremersee.keycloak.api.webflux;
  
  import jakarta.validation.Valid;
  import jakarta.validation.constraints.Pattern;
  import java.util.List;
  import java.util.Map;
  import org.bremersee.keycloak.api.model.AbstractPolicyRepresentation;
  import org.bremersee.keycloak.api.model.AccessToken;
  import org.bremersee.keycloak.api.model.AdminEventRepresentation;
  import org.bremersee.keycloak.api.model.AuthenticationExecutionInfoRepresentation;
  import org.bremersee.keycloak.api.model.AuthenticationExecutionRepresentation;
  import org.bremersee.keycloak.api.model.AuthenticationFlowRepresentation;
  import org.bremersee.keycloak.api.model.AuthenticatorConfigInfoRepresentation;
  import org.bremersee.keycloak.api.model.AuthenticatorConfigRepresentation;
  import org.bremersee.keycloak.api.model.CertificateRepresentation;
  import org.bremersee.keycloak.api.model.ClientInitialAccessCreatePresentation;
  import org.bremersee.keycloak.api.model.ClientInitialAccessPresentation;
  import org.bremersee.keycloak.api.model.ClientPoliciesRepresentation;
  import org.bremersee.keycloak.api.model.ClientProfilesRepresentation;
  import org.bremersee.keycloak.api.model.ClientRepresentation;
  import org.bremersee.keycloak.api.model.ClientScopeRepresentation;
  import org.bremersee.keycloak.api.model.ClientTypesRepresentation;
  import org.bremersee.keycloak.api.model.ComponentRepresentation;
  import org.bremersee.keycloak.api.model.ComponentTypeRepresentation;
  import org.bremersee.keycloak.api.model.ConfigPropertyRepresentation;
  import org.bremersee.keycloak.api.model.CredentialRepresentation;
  import org.bremersee.keycloak.api.model.EventRepresentation;
  import org.bremersee.keycloak.api.model.FederatedIdentityRepresentation;
  import org.bremersee.keycloak.api.model.GlobalRequestResult;
  import org.bremersee.keycloak.api.model.GroupRepresentation;
  import org.bremersee.keycloak.api.model.IDToken;
  import org.bremersee.keycloak.api.model.IdentityProviderMapperRepresentation;
  import org.bremersee.keycloak.api.model.IdentityProviderMapperTypeRepresentation;
  import org.bremersee.keycloak.api.model.IdentityProviderRepresentation;
  import org.bremersee.keycloak.api.model.KeyStoreConfig;
  import org.bremersee.keycloak.api.model.KeysMetadataRepresentation;
  import org.bremersee.keycloak.api.model.ManagementPermissionReference;
  import org.bremersee.keycloak.api.model.MappingsRepresentation;
  import org.bremersee.keycloak.api.model.MemberRepresentation;
  import org.bremersee.keycloak.api.model.OrganizationInvitationRepresentation;
  import org.bremersee.keycloak.api.model.OrganizationRepresentation;
  import org.bremersee.keycloak.api.model.PolicyEvaluationRequest;
  import org.bremersee.keycloak.api.model.PolicyEvaluationResponse;
  import org.bremersee.keycloak.api.model.PolicyProviderRepresentation;
  import org.bremersee.keycloak.api.model.PolicyRepresentation;
  import org.bremersee.keycloak.api.model.ProtocolMapperEvaluationRepresentation;
  import org.bremersee.keycloak.api.model.ProtocolMapperRepresentation;
  import org.bremersee.keycloak.api.model.RealmEventsConfigRepresentation;
  import org.bremersee.keycloak.api.model.RealmRepresentation;
  import org.bremersee.keycloak.api.model.RequiredActionConfigInfoRepresentation;
  import org.bremersee.keycloak.api.model.RequiredActionConfigRepresentation;
  import org.bremersee.keycloak.api.model.RequiredActionProviderRepresentation;
  import org.bremersee.keycloak.api.model.ResourceRepresentation;
  import org.bremersee.keycloak.api.model.ResourceServerRepresentation;
  import org.bremersee.keycloak.api.model.RoleRepresentation;
  import org.bremersee.keycloak.api.model.SamlExampleResponse;
  import org.bremersee.keycloak.api.model.ScopeRepresentation;
  import org.bremersee.keycloak.api.model.UPConfig;
  import org.bremersee.keycloak.api.model.UserProfileMetadata;
  import org.bremersee.keycloak.api.model.UserRepresentation;
  import org.bremersee.keycloak.api.model.UserSessionRepresentation;
  import org.bremersee.keycloak.api.model.WorkflowRepresentation;
  import org.jspecify.annotations.Nullable;
  import org.springframework.core.io.Resource;
  import org.springframework.validation.annotation.Validated;
  import reactor.core.publisher.Flux;
  import reactor.core.publisher.Mono;
  
  /**
   * The admin api mock.
   *
   * @author Christian Bremer
   */
  @Validated
  public class AdminApiMock implements AdminApi {
  
    /**
     * Instantiates a new admin api mock.
     */
    public AdminApiMock() {
      super();
    }
  
   @Override
   public Flux<RealmRepresentation> adminRealmsGet(@Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsPost(@Valid Mono<Resource> body) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAdminEventsDelete(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Flux<AdminEventRepresentation> adminRealmsRealmAdminEventsGet(String realm,
       @Nullable @Valid String authClient, @Nullable @Valid String authIpAddress,
       @Nullable @Valid String authRealm, @Nullable @Valid String authUser,
       @Nullable @Valid String dateFrom, @Nullable @Valid String dateTo,
       @Nullable @Valid String direction, @Nullable @Valid Integer first,
       @Nullable @Valid Integer max, @Nullable @Valid List<String> operationTypes,
       @Nullable @Valid String resourcePath, @Nullable @Valid List<String> resourceTypes) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAttackDetectionBruteForceUsersDelete(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAttackDetectionBruteForceUsersUserIdDelete(String realm,
       String userId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Map<String, Object>> adminRealmsRealmAttackDetectionBruteForceUsersUserIdGet(
       String realm, String userId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<Map<String, Object>> adminRealmsRealmAuthenticationAuthenticatorProvidersGet(
       String realm) {
     return Flux.empty();
   }
 
   @Override
   public Flux<Map<String, Object>> adminRealmsRealmAuthenticationClientAuthenticatorProvidersGet(
       String realm) {
     return Flux.empty();
   }
 
   @Override
   public Mono<AuthenticatorConfigInfoRepresentation> adminRealmsRealmAuthenticationConfigDescriptionProviderIdGet(
       String realm, String providerId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationConfigIdDelete(String realm, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<AuthenticatorConfigRepresentation> adminRealmsRealmAuthenticationConfigIdGet(
       String realm, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationConfigIdPut(String realm, String id,
       @Valid Mono<AuthenticatorConfigRepresentation> authenticatorConfigRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationConfigPost(String realm,
       @Valid Mono<AuthenticatorConfigRepresentation> authenticatorConfigRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<AuthenticatorConfigRepresentation> adminRealmsRealmAuthenticationExecutionsExecutionIdConfigIdGet(
       String realm, String executionId, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationExecutionsExecutionIdConfigPost(String realm,
       String executionId,
       @Valid Mono<AuthenticatorConfigRepresentation> authenticatorConfigRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationExecutionsExecutionIdDelete(String realm,
       String executionId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<AuthenticationExecutionRepresentation> adminRealmsRealmAuthenticationExecutionsExecutionIdGet(
       String realm, String executionId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationExecutionsExecutionIdLowerPriorityPost(
       String realm, String executionId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationExecutionsExecutionIdRaisePriorityPost(
       String realm, String executionId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationExecutionsPost(String realm,
       @Valid Mono<AuthenticationExecutionRepresentation> authenticationExecutionRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationFlowsFlowAliasCopyPost(String realm,
       String flowAlias, @Valid Mono<Map<String, String>> requestBody) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsExecutionPost(
       String realm, String flowAlias, @Valid Mono<Map<String, Object>> requestBody) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsFlowPost(String realm,
       String flowAlias, @Valid Mono<Map<String, Object>> requestBody) {
     return Mono.empty();
   }
 
   @Override
   public Flux<AuthenticationExecutionInfoRepresentation> adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsGet(
       String realm, String flowAlias) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsPut(String realm,
       String flowAlias,
       @Valid Mono<AuthenticationExecutionInfoRepresentation> authenticationExecutionInfoRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<AuthenticationFlowRepresentation> adminRealmsRealmAuthenticationFlowsGet(
       String realm) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationFlowsIdDelete(String realm, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<AuthenticationFlowRepresentation> adminRealmsRealmAuthenticationFlowsIdGet(
       String realm, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationFlowsIdPut(String realm, String id,
       @Valid Mono<AuthenticationFlowRepresentation> authenticationFlowRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationFlowsPost(String realm,
       @Valid Mono<AuthenticationFlowRepresentation> authenticationFlowRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<Map<String, Object>> adminRealmsRealmAuthenticationFormActionProvidersGet(
       String realm) {
     return Flux.empty();
   }
 
   @Override
   public Flux<Map<String, Object>> adminRealmsRealmAuthenticationFormProvidersGet(String realm) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Map<String, List<ConfigPropertyRepresentation>>> adminRealmsRealmAuthenticationPerClientConfigDescriptionGet(
       String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationRegisterRequiredActionPost(String realm,
       @Valid Mono<Map<String, String>> requestBody) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasConfigDelete(String realm,
       String alias) {
     return Mono.empty();
   }
 
   @Override
   public Mono<RequiredActionConfigInfoRepresentation> adminRealmsRealmAuthenticationRequiredActionsAliasConfigDescriptionGet(
       String realm, String alias) {
     return Mono.empty();
   }
 
   @Override
   public Mono<RequiredActionConfigRepresentation> adminRealmsRealmAuthenticationRequiredActionsAliasConfigGet(
       String realm, String alias) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasConfigPut(String realm,
       String alias,
       @Valid Mono<RequiredActionConfigRepresentation> requiredActionConfigRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasDelete(String realm,
       String alias) {
     return Mono.empty();
   }
 
   @Override
   public Mono<RequiredActionProviderRepresentation> adminRealmsRealmAuthenticationRequiredActionsAliasGet(
       String realm, String alias) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasLowerPriorityPost(
       String realm, String alias) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasPut(String realm,
       String alias,
       @Valid Mono<RequiredActionProviderRepresentation> requiredActionProviderRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasRaisePriorityPost(
       String realm, String alias) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RequiredActionProviderRepresentation> adminRealmsRealmAuthenticationRequiredActionsGet(
       String realm) {
     return Flux.empty();
   }
 
   @Override
   public Flux<Map<String, String>> adminRealmsRealmAuthenticationUnregisteredRequiredActionsGet(
       String realm) {
     return Flux.empty();
   }
 
   @Override
   public Mono<ClientRepresentation> adminRealmsRealmClientDescriptionConverterPost(String realm,
       @Valid Mono<String> body) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ClientPoliciesRepresentation> adminRealmsRealmClientPoliciesPoliciesGet(String realm,
       @Nullable @Valid Boolean includeGlobalPolicies) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientPoliciesPoliciesPut(String realm,
       @Valid Mono<ClientPoliciesRepresentation> clientPoliciesRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ClientProfilesRepresentation> adminRealmsRealmClientPoliciesProfilesGet(String realm,
       @Nullable @Valid Boolean includeGlobalProfiles) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientPoliciesProfilesPut(String realm,
       @Valid Mono<ClientProfilesRepresentation> clientProfilesRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ComponentTypeRepresentation> adminRealmsRealmClientRegistrationPolicyProvidersGet(
       String realm) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdDelete(String realm,
       String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ClientScopeRepresentation> adminRealmsRealmClientScopesClientScopeIdGet(String realm,
       String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPost(
       String realm, String clientScopeId,
       @Valid Flux<ProtocolMapperRepresentation> protocolMapperRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ProtocolMapperRepresentation> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGet(
       String realm, String clientScopeId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDelete(
       String realm, String clientScopeId, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ProtocolMapperRepresentation> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGet(
       String realm, String clientScopeId, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPut(
       String realm, String clientScopeId, String id,
       @Valid Mono<ProtocolMapperRepresentation> protocolMapperRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPost(String realm,
       String clientScopeId,
       @Valid Mono<ProtocolMapperRepresentation> protocolMapperRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ProtocolMapperRepresentation> adminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGet(
       String realm, String clientScopeId, String protocol) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdPut(String realm, String clientScopeId,
       @Valid Mono<ClientScopeRepresentation> clientScopeRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientAvailableGet(
       String realm, String clientScopeId, String client) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientCompositeGet(
       String realm, String clientScopeId, String client, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientDelete(
       String realm, String clientScopeId, String client,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientGet(
       String realm, String clientScopeId, String client) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientPost(
       String realm, String clientScopeId, String client,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<MappingsRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsGet(
       String realm, String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmAvailableGet(
       String realm, String clientScopeId) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmCompositeGet(
       String realm, String clientScopeId, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmDelete(String realm,
       String clientScopeId, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmGet(
       String realm, String clientScopeId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmPost(String realm,
       String clientScopeId, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ClientScopeRepresentation> adminRealmsRealmClientScopesGet(String realm) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientScopesPost(String realm,
       @Valid Mono<ClientScopeRepresentation> clientScopeRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<Map<String, String>> adminRealmsRealmClientSessionStatsGet(String realm) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdDelete(String realm,
       String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ClientScopeRepresentation> adminRealmsRealmClientTemplatesClientScopeIdGet(
       String realm, String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPost(
       String realm, String clientScopeId,
       @Valid Flux<ProtocolMapperRepresentation> protocolMapperRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ProtocolMapperRepresentation> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGet(
       String realm, String clientScopeId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDelete(
       String realm, String clientScopeId, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ProtocolMapperRepresentation> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGet(
       String realm, String clientScopeId, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPut(
       String realm, String clientScopeId, String id,
       @Valid Mono<ProtocolMapperRepresentation> protocolMapperRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPost(
       String realm, String clientScopeId,
       @Valid Mono<ProtocolMapperRepresentation> protocolMapperRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ProtocolMapperRepresentation> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGet(
       String realm, String clientScopeId, String protocol) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdPut(String realm,
       String clientScopeId, @Valid Mono<ClientScopeRepresentation> clientScopeRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientAvailableGet(
       String realm, String clientScopeId, String client) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientCompositeGet(
       String realm, String clientScopeId, String client, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientDelete(
       String realm, String clientScopeId, String client,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientGet(
       String realm, String clientScopeId, String client) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientPost(
       String realm, String clientScopeId, String client,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<MappingsRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsGet(
       String realm, String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmAvailableGet(
       String realm, String clientScopeId) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmCompositeGet(
       String realm, String clientScopeId, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmDelete(
       String realm, String clientScopeId, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmGet(
       String realm, String clientScopeId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmPost(String realm,
       String clientScopeId, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ClientScopeRepresentation> adminRealmsRealmClientTemplatesGet(String realm) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientTemplatesPost(String realm,
       @Valid Mono<ClientScopeRepresentation> clientScopeRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ClientTypesRepresentation> adminRealmsRealmClientTypesGet(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientTypesPut(String realm,
       @Valid Mono<ClientTypesRepresentation> clientTypesRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ResourceServerRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerGet(
       String realm, String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerImportPost(String realm,
       String clientUuid, @Valid Mono<ResourceServerRepresentation> resourceServerRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<PolicyEvaluationResponse> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionEvaluatePost(
       String realm, String clientUuid,
       @Valid Mono<PolicyEvaluationRequest> policyEvaluationRequest) {
     return Mono.empty();
   }
 
   @Override
   public Flux<AbstractPolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionGet(
       String realm, String clientUuid, @Nullable @Valid String fields,
       @Nullable @Valid Integer first, @Nullable @Valid Integer max, @Nullable @Valid String name,
       @Nullable @Valid String owner, @Nullable @Valid Boolean permission,
       @Nullable @Valid String policyId, @Nullable @Valid String resource,
       @Nullable @Valid String resourceType, @Nullable @Valid String scope,
       @Nullable @Valid String type) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionPost(String realm,
       String clientUuid, @Valid Mono<String> body) {
     return Mono.empty();
   }
 
   @Override
   public Flux<PolicyProviderRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionProvidersGet(
       String realm, String clientUuid) {
     return Flux.empty();
   }
 
   @Override
   public Mono<AbstractPolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionSearchGet(
       String realm, String clientUuid, @Nullable @Valid String fields,
       @Nullable @Valid String name) {
     return Mono.empty();
   }
 
   @Override
   public Mono<PolicyEvaluationResponse> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyEvaluatePost(
       String realm, String clientUuid,
       @Valid Mono<PolicyEvaluationRequest> policyEvaluationRequest) {
     return Mono.empty();
   }
 
   @Override
   public Flux<AbstractPolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyGet(
       String realm, String clientUuid, @Nullable @Valid String fields,
       @Nullable @Valid Integer first, @Nullable @Valid Integer max, @Nullable @Valid String name,
       @Nullable @Valid String owner, @Nullable @Valid Boolean permission,
       @Nullable @Valid String policyId, @Nullable @Valid String resource,
       @Nullable @Valid String resourceType, @Nullable @Valid String scope,
       @Nullable @Valid String type) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyPost(String realm,
       String clientUuid, @Valid Mono<String> body) {
     return Mono.empty();
   }
 
   @Override
   public Flux<PolicyProviderRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyProvidersGet(
       String realm, String clientUuid) {
     return Flux.empty();
   }
 
   @Override
   public Mono<AbstractPolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicySearchGet(
       String realm, String clientUuid, @Nullable @Valid String fields,
       @Nullable @Valid String name) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerPut(String realm,
       String clientUuid, @Valid Mono<ResourceServerRepresentation> resourceServerRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceGet(
       String realm, String clientUuid, @Nullable @Valid String id, @Nullable @Valid Boolean deep,
       @Nullable @Valid Boolean exactName, @Nullable @Valid Integer first,
       @Nullable @Valid Boolean matchingUri, @Nullable @Valid Integer max,
       @Nullable @Valid String name, @Nullable @Valid String owner, @Nullable @Valid String scope,
       @Nullable @Valid String type, @Nullable @Valid String uri) {
     return Flux.empty();
   }
 
   @Override
   public Mono<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourcePost(
       String realm, String clientUuid, @Nullable @Valid String id, @Nullable @Valid Boolean deep,
       @Nullable @Valid Boolean exactName, @Nullable @Valid Integer first,
       @Nullable @Valid Boolean matchingUri, @Nullable @Valid Integer max,
       @Nullable @Valid String name, @Nullable @Valid String owner, @Nullable @Valid String scope,
       @Nullable @Valid String type, @Nullable @Valid String uri,
       @Valid Mono<ResourceRepresentation> resourceRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdAttributesGet(
       String realm, String clientUuid, String resourceId, @Nullable @Valid String id,
       @Nullable @Valid Boolean deep, @Nullable @Valid Boolean exactName,
       @Nullable @Valid Integer first, @Nullable @Valid Boolean matchingUri,
       @Nullable @Valid Integer max, @Nullable @Valid String name, @Nullable @Valid String owner,
       @Nullable @Valid String scope, @Nullable @Valid String type, @Nullable @Valid String uri) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdDelete(
       String realm, String clientUuid, String resourceId, @Nullable @Valid String id,
       @Nullable @Valid Boolean deep, @Nullable @Valid Boolean exactName,
       @Nullable @Valid Integer first, @Nullable @Valid Boolean matchingUri,
       @Nullable @Valid Integer max, @Nullable @Valid String name, @Nullable @Valid String owner,
       @Nullable @Valid String scope, @Nullable @Valid String type, @Nullable @Valid String uri) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdGet(
       String realm, String clientUuid, String resourceId, @Nullable @Valid String id,
       @Nullable @Valid Boolean deep, @Nullable @Valid Boolean exactName,
       @Nullable @Valid Integer first, @Nullable @Valid Boolean matchingUri,
       @Nullable @Valid Integer max, @Nullable @Valid String name, @Nullable @Valid String owner,
       @Nullable @Valid String scope, @Nullable @Valid String type, @Nullable @Valid String uri) {
     return Mono.empty();
   }
 
   @Override
   public Flux<PolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdPermissionsGet(
       String realm, String clientUuid, String resourceId, @Nullable @Valid String id,
       @Nullable @Valid Boolean deep, @Nullable @Valid Boolean exactName,
       @Nullable @Valid Integer first, @Nullable @Valid Boolean matchingUri,
       @Nullable @Valid Integer max, @Nullable @Valid String name, @Nullable @Valid String owner,
       @Nullable @Valid String scope, @Nullable @Valid String type, @Nullable @Valid String uri) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdPut(
       String realm, String clientUuid, String resourceId, @Nullable @Valid String id,
       @Nullable @Valid Boolean deep, @Nullable @Valid Boolean exactName,
       @Nullable @Valid Integer first, @Nullable @Valid Boolean matchingUri,
       @Nullable @Valid Integer max, @Nullable @Valid String name, @Nullable @Valid String owner,
       @Nullable @Valid String scope, @Nullable @Valid String type, @Nullable @Valid String uri,
       @Valid Mono<ResourceRepresentation> resourceRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ScopeRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdScopesGet(
       String realm, String clientUuid, String resourceId, @Nullable @Valid String id,
       @Nullable @Valid Boolean deep, @Nullable @Valid Boolean exactName,
       @Nullable @Valid Integer first, @Nullable @Valid Boolean matchingUri,
       @Nullable @Valid Integer max, @Nullable @Valid String name, @Nullable @Valid String owner,
       @Nullable @Valid String scope, @Nullable @Valid String type, @Nullable @Valid String uri) {
     return Flux.empty();
   }
 
   @Override
   public Mono<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceSearchGet(
       String realm, String clientUuid, @Nullable @Valid String id, @Nullable @Valid Boolean deep,
       @Nullable @Valid Boolean exactName, @Nullable @Valid Integer first,
       @Nullable @Valid Boolean matchingUri, @Nullable @Valid Integer max,
       @Nullable @Valid String owner, @Nullable @Valid String scope, @Nullable @Valid String type,
       @Nullable @Valid String uri, @Nullable @Valid String name) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ScopeRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeGet(
       String realm, String clientUuid, @Nullable @Valid Integer first, @Nullable @Valid Integer max,
       @Nullable @Valid String name, @Nullable @Valid String scopeId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerScopePost(String realm,
       String clientUuid, @Valid Mono<ScopeRepresentation> scopeRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdDelete(
       String realm, String clientUuid, String scopeId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ScopeRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdGet(
       String realm, String clientUuid, String scopeId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<PolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdPermissionsGet(
       String realm, String clientUuid, String scopeId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdPut(
       String realm, String clientUuid, String scopeId,
       @Valid Mono<ScopeRepresentation> scopeRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdResourcesGet(
       String realm, String clientUuid, String scopeId) {
     return Flux.empty();
   }
 
   @Override
   public Flux<ScopeRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeSearchGet(
       String realm, String clientUuid, @Nullable @Valid String name) {
     return Flux.empty();
   }
 
   @Override
   public Mono<ResourceServerRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerSettingsGet(
       String realm, String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Resource> adminRealmsRealmClientsClientUuidCertificatesAttrDownloadPost(String realm,
       String clientUuid, String attr, @Valid Mono<KeyStoreConfig> keyStoreConfig) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Resource> adminRealmsRealmClientsClientUuidCertificatesAttrGenerateAndDownloadPost(
       String realm, String clientUuid, String attr, @Valid Mono<KeyStoreConfig> keyStoreConfig) {
     return Mono.empty();
   }
 
   @Override
   public Mono<CertificateRepresentation> adminRealmsRealmClientsClientUuidCertificatesAttrGeneratePost(
       String realm, String clientUuid, String attr) {
     return Mono.empty();
   }
 
   @Override
   public Mono<CertificateRepresentation> adminRealmsRealmClientsClientUuidCertificatesAttrGet(
       String realm, String clientUuid, String attr) {
     return Mono.empty();
   }
 
   @Override
   public Mono<CertificateRepresentation> adminRealmsRealmClientsClientUuidCertificatesAttrUploadCertificatePost(
       String realm, String clientUuid, String attr) {
     return Mono.empty();
   }
 
   @Override
   public Mono<CertificateRepresentation> adminRealmsRealmClientsClientUuidCertificatesAttrUploadPost(
       String realm, String clientUuid, String attr) {
     return Mono.empty();
   }
 
   @Override
   public Mono<CredentialRepresentation> adminRealmsRealmClientsClientUuidClientSecretGet(
       String realm, String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Mono<CredentialRepresentation> adminRealmsRealmClientsClientUuidClientSecretPost(
       String realm, String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidClientSecretRotatedDelete(String realm,
       String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Mono<CredentialRepresentation> adminRealmsRealmClientsClientUuidClientSecretRotatedGet(
       String realm, String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidDefaultClientScopesClientScopeIdDelete(
       String realm, String clientUuid, String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidDefaultClientScopesClientScopeIdPut(
       String realm, String clientUuid, String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ClientScopeRepresentation> adminRealmsRealmClientsClientUuidDefaultClientScopesGet(
       String realm, String clientUuid) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidDelete(String realm, String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Mono<AccessToken> adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleAccessTokenGet(
       String realm, String clientUuid, @Nullable @Valid String audience,
       @Nullable @Valid String scope, @Nullable @Valid String userId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<IDToken> adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleIdTokenGet(
       String realm, String clientUuid, @Nullable @Valid String audience,
       @Nullable @Valid String scope, @Nullable @Valid String userId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<SamlExampleResponse> adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleSamlResponseGet(
       String realm, String clientUuid, @Nullable @Valid String audience,
       @Nullable @Valid String scope, @Nullable @Valid String userId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Object> adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleUserinfoGet(
       String realm, String clientUuid, @Nullable @Valid String scope,
       @Nullable @Valid String userId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ProtocolMapperEvaluationRepresentation> adminRealmsRealmClientsClientUuidEvaluateScopesProtocolMappersGet(
       String realm, String clientUuid, @Nullable @Valid String scope) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidEvaluateScopesScopeMappingsRoleContainerIdGrantedGet(
       String realm, String clientUuid, String roleContainerId, @Nullable @Valid String scope) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidEvaluateScopesScopeMappingsRoleContainerIdNotGrantedGet(
       String realm, String clientUuid, String roleContainerId, @Nullable @Valid String scope) {
     return Flux.empty();
   }
 
   @Override
   public Mono<ClientRepresentation> adminRealmsRealmClientsClientUuidGet(String realm,
       String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidInstallationProvidersProviderIdGet(
       String realm, String clientUuid, String providerId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmClientsClientUuidManagementPermissionsGet(
       String realm, String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmClientsClientUuidManagementPermissionsPut(
       String realm, String clientUuid,
       @Valid Mono<ManagementPermissionReference> managementPermissionReference) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidNodesNodeDelete(String realm,
       String clientUuid, String node) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidNodesPost(String realm, String clientUuid,
       @Valid Mono<Map<String, String>> requestBody) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Map<String, Long>> adminRealmsRealmClientsClientUuidOfflineSessionCountGet(
       String realm, String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Flux<UserSessionRepresentation> adminRealmsRealmClientsClientUuidOfflineSessionsGet(
       String realm, String clientUuid, @Nullable @Valid Integer first,
       @Nullable @Valid Integer max) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidOptionalClientScopesClientScopeIdDelete(
       String realm, String clientUuid, String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidOptionalClientScopesClientScopeIdPut(
       String realm, String clientUuid, String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ClientScopeRepresentation> adminRealmsRealmClientsClientUuidOptionalClientScopesGet(
       String realm, String clientUuid) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidProtocolMappersAddModelsPost(String realm,
       String clientUuid, @Valid Flux<ProtocolMapperRepresentation> protocolMapperRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ProtocolMapperRepresentation> adminRealmsRealmClientsClientUuidProtocolMappersModelsGet(
       String realm, String clientUuid) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidProtocolMappersModelsIdDelete(String realm,
       String clientUuid, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ProtocolMapperRepresentation> adminRealmsRealmClientsClientUuidProtocolMappersModelsIdGet(
       String realm, String clientUuid, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidProtocolMappersModelsIdPut(String realm,
       String clientUuid, String id,
       @Valid Mono<ProtocolMapperRepresentation> protocolMapperRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidProtocolMappersModelsPost(String realm,
       String clientUuid, @Valid Mono<ProtocolMapperRepresentation> protocolMapperRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ProtocolMapperRepresentation> adminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGet(
       String realm, String clientUuid, String protocol) {
     return Flux.empty();
   }
 
   @Override
   public Mono<GlobalRequestResult> adminRealmsRealmClientsClientUuidPushRevocationPost(String realm,
       String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidPut(String realm, String clientUuid,
       @Valid Mono<ClientRepresentation> clientRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ClientRepresentation> adminRealmsRealmClientsClientUuidRegistrationAccessTokenPost(
       String realm, String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesGet(String realm,
       String clientUuid, @Valid Boolean briefRepresentation, @Nullable @Valid Integer first,
       @Nullable @Valid Integer max, @Valid String search) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidRolesPost(String realm, String clientUuid,
       @Valid Mono<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesClientsTargetClientUuidGet(
       String realm, String clientUuid, String roleName, String targetClientUuid) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesDelete(String realm,
       String clientUuid, String roleName, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesGet(
       String realm, String clientUuid, String roleName) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesPost(String realm,
       String clientUuid, String roleName, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesRealmGet(
       String realm, String clientUuid, String roleName) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidRolesRoleNameDelete(String realm,
       String clientUuid, String roleName) {
     return Mono.empty();
   }
 
   @Override
   public Mono<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameGet(String realm,
       String clientUuid, String roleName) {
     return Mono.empty();
   }
 
   @Override
   public Flux<UserRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameGroupsGet(
       String realm, String clientUuid, String roleName, @Nullable @Valid Integer max,
       @Valid Boolean briefRepresentation, @Nullable @Valid Integer first) {
     return Flux.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmClientsClientUuidRolesRoleNameManagementPermissionsGet(
       String realm, String clientUuid, String roleName) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmClientsClientUuidRolesRoleNameManagementPermissionsPut(
       String realm, String clientUuid, String roleName,
       @Valid Mono<ManagementPermissionReference> managementPermissionReference) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidRolesRoleNamePut(String realm,
       String clientUuid, String roleName, @Valid Mono<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<UserRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameUsersGet(
       String realm, String clientUuid, String roleName,
       @Nullable @Valid Boolean briefRepresentation, @Nullable @Valid Integer first,
       @Nullable @Valid Integer max) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientAvailableGet(
       String realm, String clientUuid, String client) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientCompositeGet(
       String realm, String clientUuid, String client, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientDelete(String realm,
       String clientUuid, String client, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientGet(
       String realm, String clientUuid, String client) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientPost(String realm,
       String clientUuid, String client, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<MappingsRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsGet(
       String realm, String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsRealmAvailableGet(
       String realm, String clientUuid) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsRealmCompositeGet(
       String realm, String clientUuid, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidScopeMappingsRealmDelete(String realm,
       String clientUuid, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsRealmGet(
       String realm, String clientUuid) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsClientUuidScopeMappingsRealmPost(String realm,
       String clientUuid, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<UserRepresentation> adminRealmsRealmClientsClientUuidServiceAccountUserGet(
       String realm, String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Map<String, Long>> adminRealmsRealmClientsClientUuidSessionCountGet(String realm,
       String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Mono<GlobalRequestResult> adminRealmsRealmClientsClientUuidTestNodesAvailableGet(
       String realm, String clientUuid) {
     return Mono.empty();
   }
 
   @Override
   public Flux<UserSessionRepresentation> adminRealmsRealmClientsClientUuidUserSessionsGet(
       String realm, String clientUuid, @Nullable @Valid Integer first,
       @Nullable @Valid Integer max) {
     return Flux.empty();
   }
 
   @Override
   public Flux<ClientRepresentation> adminRealmsRealmClientsGet(String realm,
       @Nullable @Valid String clientId, @Nullable @Valid Integer first,
       @Nullable @Valid Integer max, @Nullable @Valid String q, @Valid Boolean search,
       @Valid Boolean viewableOnly) {
     return Flux.empty();
   }
 
   @Override
   public Flux<ClientInitialAccessPresentation> adminRealmsRealmClientsInitialAccessGet(
       String realm) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsInitialAccessIdDelete(String realm, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ClientInitialAccessCreatePresentation> adminRealmsRealmClientsInitialAccessPost(
       String realm,
       @Valid Mono<ClientInitialAccessCreatePresentation> clientInitialAccessCreatePresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmClientsPost(String realm,
       @Valid Mono<ClientRepresentation> clientRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ComponentRepresentation> adminRealmsRealmComponentsGet(String realm,
       @Nullable @Valid String name, @Nullable @Valid String parent,
       @Nullable @Valid String providerId, @Nullable @Valid String type) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmComponentsIdDelete(String realm, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ComponentRepresentation> adminRealmsRealmComponentsIdGet(String realm, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmComponentsIdPut(String realm, String id,
       @Valid Mono<ComponentRepresentation> componentRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ComponentTypeRepresentation> adminRealmsRealmComponentsIdSubComponentTypesGet(
       String realm, String id, @Nullable @Valid String type) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmComponentsPost(String realm,
       @Valid Mono<ComponentRepresentation> componentRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<List<String>> adminRealmsRealmCredentialRegistratorsGet(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmDefaultDefaultClientScopesClientScopeIdDelete(String realm,
       String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmDefaultDefaultClientScopesClientScopeIdPut(String realm,
       String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ClientScopeRepresentation> adminRealmsRealmDefaultDefaultClientScopesGet(
       String realm) {
     return Flux.empty();
   }
 
   @Override
   public Flux<GroupRepresentation> adminRealmsRealmDefaultGroupsGet(String realm) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmDefaultGroupsGroupIdDelete(String realm, String groupId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmDefaultGroupsGroupIdPut(String realm, String groupId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmDefaultOptionalClientScopesClientScopeIdDelete(String realm,
       String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmDefaultOptionalClientScopesClientScopeIdPut(String realm,
       String clientScopeId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<ClientScopeRepresentation> adminRealmsRealmDefaultOptionalClientScopesGet(
       String realm) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmDelete(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<RealmEventsConfigRepresentation> adminRealmsRealmEventsConfigGet(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmEventsConfigPut(String realm,
       @Valid Mono<RealmEventsConfigRepresentation> realmEventsConfigRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmEventsDelete(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Flux<EventRepresentation> adminRealmsRealmEventsGet(String realm,
       @Nullable @Valid String client, @Nullable @Valid String dateFrom,
       @Nullable @Valid String dateTo, @Nullable @Valid String direction,
       @Nullable @Valid Integer first, @Nullable @Valid String ipAddress,
       @Nullable @Valid Integer max, @Nullable @Valid List<String> type,
       @Nullable @Valid String user) {
     return Flux.empty();
   }
 
   @Override
   public Mono<RealmRepresentation> adminRealmsRealmGet(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<GroupRepresentation> adminRealmsRealmGroupByPathPathGet(String realm,
       @Pattern(regexp = ".*") String path) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Map<String, Long>> adminRealmsRealmGroupsCountGet(String realm,
       @Nullable @Valid String search, @Valid Boolean top) {
     return Mono.empty();
   }
 
   @Override
   public Flux<GroupRepresentation> adminRealmsRealmGroupsGet(String realm,
       @Valid Boolean briefRepresentation, @Valid Boolean exact, @Nullable @Valid Integer first,
       @Nullable @Valid Integer max, @Valid Boolean populateHierarchy, @Nullable @Valid String q,
       @Nullable @Valid String search, @Valid Boolean subGroupsCount) {
     return Flux.empty();
   }
 
   @Override
   public Flux<GroupRepresentation> adminRealmsRealmGroupsGroupIdChildrenGet(String realm,
       String groupId, @Valid Boolean briefRepresentation, @Nullable @Valid Boolean exact,
       @Nullable @Valid Integer first, @Nullable @Valid Integer max, @Nullable @Valid String search,
       @Valid Boolean subGroupsCount) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmGroupsGroupIdChildrenPost(String realm, String groupId,
       @Valid Mono<GroupRepresentation> groupRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmGroupsGroupIdDelete(String realm, String groupId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<GroupRepresentation> adminRealmsRealmGroupsGroupIdGet(String realm, String groupId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmGroupsGroupIdManagementPermissionsGet(
       String realm, String groupId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmGroupsGroupIdManagementPermissionsPut(
       String realm, String groupId,
       @Valid Mono<ManagementPermissionReference> managementPermissionReference) {
     return Mono.empty();
   }
 
   @Override
   public Flux<UserRepresentation> adminRealmsRealmGroupsGroupIdMembersGet(String realm,
       String groupId, @Nullable @Valid Boolean briefRepresentation, @Nullable @Valid Integer first,
       @Nullable @Valid Integer max) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmGroupsGroupIdPut(String realm, String groupId,
       @Valid Mono<GroupRepresentation> groupRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdAvailableGet(
       String realm, String groupId, String clientId) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdCompositeGet(
       String realm, String groupId, String clientId, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdDelete(String realm,
       String groupId, String clientId, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdGet(
       String realm, String groupId, String clientId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdPost(String realm,
       String groupId, String clientId, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<MappingsRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsGet(String realm,
       String groupId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsRealmAvailableGet(
       String realm, String groupId) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsRealmCompositeGet(
       String realm, String groupId, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmGroupsGroupIdRoleMappingsRealmDelete(String realm,
       String groupId, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsRealmGet(String realm,
       String groupId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmGroupsGroupIdRoleMappingsRealmPost(String realm, String groupId,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmGroupsPost(String realm,
       @Valid Mono<GroupRepresentation> groupRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Map<String, String>> adminRealmsRealmIdentityProviderImportConfigPost(String realm,
       @Valid Mono<Map<String, Object>> requestBody) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasDelete(String realm,
       String alias) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasExportGet(String realm,
       String alias, @Nullable @Valid String format) {
     return Mono.empty();
   }
 
   @Override
   public Mono<IdentityProviderRepresentation> adminRealmsRealmIdentityProviderInstancesAliasGet(
       String realm, String alias) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGet(
       String realm, String alias) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPut(
       String realm, String alias,
       @Valid Mono<ManagementPermissionReference> managementPermissionReference) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Map<String, IdentityProviderMapperTypeRepresentation>> adminRealmsRealmIdentityProviderInstancesAliasMapperTypesGet(
       String realm, String alias) {
     return Mono.empty();
   }
 
   @Override
   public Flux<IdentityProviderMapperRepresentation> adminRealmsRealmIdentityProviderInstancesAliasMappersGet(
       String realm, String alias) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasMappersIdDelete(String realm,
       String alias, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<IdentityProviderMapperRepresentation> adminRealmsRealmIdentityProviderInstancesAliasMappersIdGet(
       String realm, String alias, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasMappersIdPut(String realm,
       String alias, String id,
       @Valid Mono<IdentityProviderMapperRepresentation> identityProviderMapperRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasMappersPost(String realm,
       String alias,
       @Valid Mono<IdentityProviderMapperRepresentation> identityProviderMapperRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasPut(String realm, String alias,
       @Valid Mono<IdentityProviderRepresentation> identityProviderRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Boolean> adminRealmsRealmIdentityProviderInstancesAliasReloadKeysGet(String realm,
       String alias) {
     return Mono.empty();
   }
 
   @Override
   public Flux<IdentityProviderRepresentation> adminRealmsRealmIdentityProviderInstancesGet(
       String realm, @Nullable @Valid Boolean briefRepresentation,
       @Nullable @Valid String capability, @Nullable @Valid Integer first,
       @Nullable @Valid Integer max, @Nullable @Valid Boolean realmOnly,
       @Nullable @Valid String search, @Nullable @Valid String type) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmIdentityProviderInstancesPost(String realm,
       @Valid Mono<IdentityProviderRepresentation> identityProviderRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Object> adminRealmsRealmIdentityProviderProvidersProviderIdGet(String realm,
       String providerId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<CertificateRepresentation> adminRealmsRealmIdentityProviderUploadCertificatePost(
       String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<KeysMetadataRepresentation> adminRealmsRealmKeysGet(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<List<String>> adminRealmsRealmLocalizationGet(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmLocalizationLocaleDelete(String realm, String locale) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Map<String, String>> adminRealmsRealmLocalizationLocaleGet(String realm,
       String locale, @Nullable @Valid Boolean useRealmDefaultLocaleFallback) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmLocalizationLocaleKeyDelete(String realm, String key,
       String locale) {
     return Mono.empty();
   }
 
   @Override
   public Mono<String> adminRealmsRealmLocalizationLocaleKeyGet(String realm, String key,
       String locale) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmLocalizationLocaleKeyPut(String realm, String key,
       String locale, @Valid Mono<String> body) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmLocalizationLocalePost(String realm, String locale,
       @Valid Mono<Map<String, String>> requestBody) {
     return Mono.empty();
   }
 
   @Override
   public Mono<GlobalRequestResult> adminRealmsRealmLogoutAllPost(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Long> adminRealmsRealmOrganizationsCountGet(String realm,
       @Nullable @Valid Boolean exact, @Nullable @Valid String q, @Nullable @Valid String search) {
     return Mono.empty();
   }
 
   @Override
   public Flux<OrganizationRepresentation> adminRealmsRealmOrganizationsGet(String realm,
       @Valid Boolean briefRepresentation, @Nullable @Valid Boolean exact,
       @Nullable @Valid Integer first, @Nullable @Valid Integer max, @Nullable @Valid String q,
       @Nullable @Valid String search) {
     return Flux.empty();
   }
 
   @Override
   public Flux<OrganizationRepresentation> adminRealmsRealmOrganizationsMembersMemberIdOrganizationsGet(
       String realm, String memberId, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdDelete(String realm, String orgId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<OrganizationRepresentation> adminRealmsRealmOrganizationsOrgIdGet(String realm,
       String orgId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGet(String realm,
       String orgId, @Valid Boolean briefRepresentation, @Valid Boolean exact,
       @Nullable @Valid Integer first, @Nullable @Valid Integer max,
       @Valid Boolean populateHierarchy, @Nullable @Valid String q, @Nullable @Valid String search,
       @Valid Boolean subGroupsCount) {
     return Flux.empty();
   }
 
   @Override
   public Mono<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupByPathPathGet(
       String realm, String orgId, @Pattern(regexp = ".*") String path,
       @Valid Boolean subGroupsCount) {
     return Mono.empty();
   }
 
   @Override
   public Flux<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdChildrenGet(
       String realm, String orgId, String groupId, @Nullable @Valid Boolean exact,
       @Nullable @Valid Integer first, @Nullable @Valid Integer max, @Nullable @Valid String search,
       @Nullable @Valid Boolean subGroupsCount) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdChildrenPost(String realm,
       String orgId, String groupId, @Valid Mono<GroupRepresentation> groupRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdDelete(String realm,
       String orgId, String groupId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdGet(String realm,
       String orgId, String groupId, @Valid Boolean subGroupsCount) {
     return Mono.empty();
   }
 
   @Override
   public Flux<MemberRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersGet(
       String realm, String orgId, String groupId, @Nullable @Valid Boolean briefRepresentation,
       @Nullable @Valid Integer first, @Nullable @Valid Integer max) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersUserIdDelete(String realm,
       String orgId, String groupId, String userId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersUserIdPut(String realm,
       String orgId, String groupId, String userId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdPut(String realm, String orgId,
       String groupId, @Valid Mono<GroupRepresentation> groupRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdAvailableGet(
       String realm, String orgId, String groupId, String clientId) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdCompositeGet(
       String realm, String orgId, String groupId, String clientId,
       @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdDelete(
       String realm, String orgId, String groupId, String clientId,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdGet(
       String realm, String orgId, String groupId, String clientId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdPost(
       String realm, String orgId, String groupId, String clientId,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<MappingsRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsGet(
       String realm, String orgId, String groupId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmAvailableGet(
       String realm, String orgId, String groupId) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmCompositeGet(
       String realm, String orgId, String groupId, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmDelete(
       String realm, String orgId, String groupId,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmGet(
       String realm, String orgId, String groupId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmPost(
       String realm, String orgId, String groupId,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsPost(String realm, String orgId,
       @Valid Mono<GroupRepresentation> groupRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasDelete(String realm,
       String orgId, String alias) {
     return Mono.empty();
   }
 
   @Override
   public Mono<IdentityProviderRepresentation> adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasGet(
       String realm, String orgId, String alias) {
     return Mono.empty();
   }
 
   @Override
   public Flux<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasGroupsGet(
       String realm, String orgId, String alias, @Valid Boolean briefRepresentation,
       @Valid Boolean exact, @Nullable @Valid Integer first, @Nullable @Valid Integer max,
       @Nullable @Valid String q, @Nullable @Valid String search, @Valid Boolean subGroupsCount) {
     return Flux.empty();
   }
 
   @Override
   public Flux<IdentityProviderRepresentation> adminRealmsRealmOrganizationsOrgIdIdentityProvidersGet(
       String realm, String orgId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdIdentityProvidersPost(String realm,
       String orgId, @Valid Mono<String> body) {
     return Mono.empty();
   }
 
   @Override
   public Flux<OrganizationInvitationRepresentation> adminRealmsRealmOrganizationsOrgIdInvitationsGet(
       String realm, String orgId, @Nullable @Valid String email, @Nullable @Valid Integer first,
       @Nullable @Valid String firstName, @Nullable @Valid String lastName,
       @Nullable @Valid Integer max, @Nullable @Valid String search,
       @Nullable @Valid String status) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdInvitationsIdDelete(String realm,
       String orgId, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<OrganizationInvitationRepresentation> adminRealmsRealmOrganizationsOrgIdInvitationsIdGet(
       String realm, String orgId, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdInvitationsIdResendPost(String realm,
       String orgId, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Long> adminRealmsRealmOrganizationsOrgIdMembersCountGet(String realm, String orgId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<MemberRepresentation> adminRealmsRealmOrganizationsOrgIdMembersGet(String realm,
       String orgId, @Valid Boolean briefRepresentation, @Nullable @Valid Boolean exact,
       @Nullable @Valid Integer first, @Nullable @Valid Integer max,
       @Nullable @Valid String membershipType, @Nullable @Valid String search) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdMembersInviteExistingUserPost(String realm,
       String orgId, @Valid String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdMembersInviteUserPost(String realm,
       String orgId, @Valid String email, @Valid String firstName, @Valid String lastName) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdMembersMemberIdDelete(String realm,
       String orgId, String memberId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<MemberRepresentation> adminRealmsRealmOrganizationsOrgIdMembersMemberIdGet(
       String realm, String orgId, String memberId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdMembersMemberIdGroupsGet(
       String realm, String orgId, String memberId, @Valid Boolean briefRepresentation,
       @Nullable @Valid Integer first, @Nullable @Valid Integer max,
       @Nullable @Valid String search) {
     return Flux.empty();
   }
 
   @Override
   public Flux<OrganizationRepresentation> adminRealmsRealmOrganizationsOrgIdMembersMemberIdOrganizationsGet(
       String realm, String orgId, String memberId, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdMembersPost(String realm, String orgId,
       @Valid Mono<String> body) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsOrgIdPut(String realm, String orgId,
       @Valid Mono<OrganizationRepresentation> organizationRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmOrganizationsPost(String realm,
       @Valid Mono<OrganizationRepresentation> organizationRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<RealmRepresentation> adminRealmsRealmPartialExportPost(String realm,
       @Nullable @Valid Boolean exportClients, @Nullable @Valid Boolean exportGroupsAndRoles) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Object> adminRealmsRealmPartialImportPost(String realm, @Valid Mono<Resource> body) {
     return Mono.empty();
   }
 
   @Override
   public Mono<GlobalRequestResult> adminRealmsRealmPushRevocationPost(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmPut(String realm,
       @Valid Mono<RealmRepresentation> realmRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmRolesByIdRoleIdCompositesClientsClientUuidGet(
       String realm, String clientUuid, String roleId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmRolesByIdRoleIdCompositesDelete(String realm, String roleId,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmRolesByIdRoleIdCompositesGet(String realm,
       String roleId, @Nullable @Valid Integer first, @Nullable @Valid Integer max,
       @Nullable @Valid String search) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmRolesByIdRoleIdCompositesPost(String realm, String roleId,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmRolesByIdRoleIdCompositesRealmGet(String realm,
       String roleId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmRolesByIdRoleIdDelete(String realm, String roleId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<RoleRepresentation> adminRealmsRealmRolesByIdRoleIdGet(String realm, String roleId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmRolesByIdRoleIdManagementPermissionsGet(
       String realm, String roleId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmRolesByIdRoleIdManagementPermissionsPut(
       String realm, String roleId,
       @Valid Mono<ManagementPermissionReference> managementPermissionReference) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmRolesByIdRoleIdPut(String realm, String roleId,
       @Valid Mono<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmRolesGet(String realm,
       @Valid Boolean briefRepresentation, @Nullable @Valid Integer first,
       @Nullable @Valid Integer max, @Valid String search) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmRolesPost(String realm,
       @Valid Mono<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmRolesRoleNameCompositesClientsTargetClientUuidGet(
       String realm, String roleName, String targetClientUuid) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmRolesRoleNameCompositesDelete(String realm, String roleName,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmRolesRoleNameCompositesGet(String realm,
       String roleName) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmRolesRoleNameCompositesPost(String realm, String roleName,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmRolesRoleNameCompositesRealmGet(String realm,
       String roleName) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmRolesRoleNameDelete(String realm, String roleName) {
     return Mono.empty();
   }
 
   @Override
   public Mono<RoleRepresentation> adminRealmsRealmRolesRoleNameGet(String realm, String roleName) {
     return Mono.empty();
   }
 
   @Override
   public Flux<UserRepresentation> adminRealmsRealmRolesRoleNameGroupsGet(String realm,
       String roleName, @Nullable @Valid Integer max, @Valid Boolean briefRepresentation,
       @Nullable @Valid Integer first) {
     return Flux.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmRolesRoleNameManagementPermissionsGet(
       String realm, String roleName) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmRolesRoleNameManagementPermissionsPut(
       String realm, String roleName,
       @Valid Mono<ManagementPermissionReference> managementPermissionReference) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmRolesRoleNamePut(String realm, String roleName,
       @Valid Mono<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<UserRepresentation> adminRealmsRealmRolesRoleNameUsersGet(String realm,
       String roleName, @Nullable @Valid Boolean briefRepresentation, @Nullable @Valid Integer first,
       @Nullable @Valid Integer max) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmSessionsSessionDelete(String realm, String session,
       @Valid Boolean isOffline) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Integer> adminRealmsRealmUsersCountGet(String realm,
       @Nullable @Valid String createdAfter, @Nullable @Valid String createdBefore,
       @Nullable @Valid String email, @Nullable @Valid Boolean emailVerified,
       @Nullable @Valid Boolean enabled, @Nullable @Valid Boolean exact,
       @Nullable @Valid String firstName, @Nullable @Valid String idpAlias,
       @Nullable @Valid String idpUserId, @Nullable @Valid String lastName,
       @Nullable @Valid String q, @Nullable @Valid String search, @Nullable @Valid String username) {
     return Mono.empty();
   }
 
   @Override
   public Flux<UserRepresentation> adminRealmsRealmUsersGet(String realm,
       @Nullable @Valid Boolean briefRepresentation, @Nullable @Valid String createdAfter,
       @Nullable @Valid String createdBefore, @Nullable @Valid String email,
       @Nullable @Valid Boolean emailVerified, @Nullable @Valid Boolean enabled,
       @Nullable @Valid Boolean exact, @Nullable @Valid Integer first,
       @Nullable @Valid String firstName, @Nullable @Valid String idpAlias,
       @Nullable @Valid String idpUserId, @Nullable @Valid String lastName,
       @Nullable @Valid Integer max, @Nullable @Valid String q, @Nullable @Valid String search,
       @Nullable @Valid String username) {
     return Flux.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmUsersManagementPermissionsGet(
       String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<ManagementPermissionReference> adminRealmsRealmUsersManagementPermissionsPut(
       String realm, @Valid Mono<ManagementPermissionReference> managementPermissionReference) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersPost(String realm,
       @Valid Mono<UserRepresentation> userRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<UPConfig> adminRealmsRealmUsersProfileGet(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<UserProfileMetadata> adminRealmsRealmUsersProfileMetadataGet(String realm) {
     return Mono.empty();
   }
 
   @Override
   public Mono<UPConfig> adminRealmsRealmUsersProfilePut(String realm,
       @Valid Mono<UPConfig> upConfig) {
     return Mono.empty();
   }
 
   @Override
   public Mono<List<String>> adminRealmsRealmUsersUserIdConfiguredUserStorageCredentialTypesGet(
       String realm, String userId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdConsentsClientDelete(String realm, String userId,
       String client) {
     return Mono.empty();
   }
 
   @Override
   public Flux<Map<String, Object>> adminRealmsRealmUsersUserIdConsentsGet(String realm,
       String userId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdCredentialsCredentialIdDelete(String realm,
       String userId, String credentialId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdCredentialsCredentialIdMoveAfterNewPreviousCredentialIdPost(
       String realm, String userId, String credentialId, String newPreviousCredentialId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdCredentialsCredentialIdMoveToFirstPost(String realm,
       String userId, String credentialId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdCredentialsCredentialIdUserLabelPut(String realm,
       String userId, String credentialId, @Valid Mono<String> body) {
     return Mono.empty();
   }
 
   @Override
   public Flux<CredentialRepresentation> adminRealmsRealmUsersUserIdCredentialsGet(String realm,
       String userId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdDelete(String realm, String userId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdDisableCredentialTypesPut(String realm,
       String userId, @Valid Flux<String> requestBody) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdExecuteActionsEmailPut(String realm, String userId,
       @Nullable @Valid String clientId, @Nullable @Valid Integer lifespan,
       @Nullable @Valid String redirectUri, @Valid Flux<String> requestBody) {
     return Mono.empty();
   }
 
   @Override
   public Flux<FederatedIdentityRepresentation> adminRealmsRealmUsersUserIdFederatedIdentityGet(
       String realm, String userId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdFederatedIdentityProviderDelete(String realm,
       String userId, String provider) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdFederatedIdentityProviderPost(String realm,
       String userId, String provider,
       @Valid Mono<FederatedIdentityRepresentation> federatedIdentityRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<UserRepresentation> adminRealmsRealmUsersUserIdGet(String realm, String userId,
       @Nullable @Valid Boolean userProfileMetadata) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Map<String, Long>> adminRealmsRealmUsersUserIdGroupsCountGet(String realm,
       String userId, @Nullable @Valid String search) {
     return Mono.empty();
   }
 
   @Override
   public Flux<GroupRepresentation> adminRealmsRealmUsersUserIdGroupsGet(String realm, String userId,
       @Valid Boolean briefRepresentation, @Nullable @Valid Integer first,
       @Nullable @Valid Integer max, @Nullable @Valid String search) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdGroupsGroupIdDelete(String realm, String userId,
       String groupId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdGroupsGroupIdPut(String realm, String userId,
       String groupId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Map<String, Object>> adminRealmsRealmUsersUserIdImpersonationPost(String realm,
       String userId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdLogoutPost(String realm, String userId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<UserSessionRepresentation> adminRealmsRealmUsersUserIdOfflineSessionsClientUuidGet(
       String realm, String userId, String clientUuid) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdPut(String realm, String userId,
       @Valid Mono<UserRepresentation> userRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdResetPasswordEmailPut(String realm, String userId,
       @Nullable @Valid String clientId, @Nullable @Valid String redirectUri) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdResetPasswordPut(String realm, String userId,
       @Valid Mono<CredentialRepresentation> credentialRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdAvailableGet(
       String realm, String userId, String clientId) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdCompositeGet(
       String realm, String userId, String clientId, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdDelete(String realm,
       String userId, String clientId, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdGet(
       String realm, String userId, String clientId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdPost(String realm,
       String userId, String clientId, @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<MappingsRepresentation> adminRealmsRealmUsersUserIdRoleMappingsGet(String realm,
       String userId) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsRealmAvailableGet(
       String realm, String userId) {
     return Flux.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsRealmCompositeGet(
       String realm, String userId, @Valid Boolean briefRepresentation) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdRoleMappingsRealmDelete(String realm, String userId,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsRealmGet(String realm,
       String userId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdRoleMappingsRealmPost(String realm, String userId,
       @Valid Flux<RoleRepresentation> roleRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmUsersUserIdSendVerifyEmailPut(String realm, String userId,
       @Nullable @Valid String clientId, @Nullable @Valid Integer lifespan,
       @Nullable @Valid String redirectUri) {
     return Mono.empty();
   }
 
   @Override
   public Flux<UserSessionRepresentation> adminRealmsRealmUsersUserIdSessionsGet(String realm,
       String userId) {
     return Flux.empty();
   }
 
   @Override
   public Mono<Map<String, List<String>>> adminRealmsRealmUsersUserIdUnmanagedAttributesGet(
       String realm, String userId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<WorkflowRepresentation> adminRealmsRealmWorkflowsGet(String realm,
       @Nullable @Valid Boolean exact, @Nullable @Valid Integer first, @Nullable @Valid Integer max,
       @Nullable @Valid String search) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmWorkflowsIdActivateTypeResourceIdPost(String realm, String id,
       String resourceId, Object type, @Nullable @Valid String notBefore) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmWorkflowsIdDeactivateTypeResourceIdPost(String realm, String id,
       String resourceId, Object type) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmWorkflowsIdDelete(String realm, String id) {
     return Mono.empty();
   }
 
   @Override
   public Mono<WorkflowRepresentation> adminRealmsRealmWorkflowsIdGet(String realm, String id,
       @Nullable @Valid Boolean includeId) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmWorkflowsIdPut(String realm, String id,
       @Valid Mono<WorkflowRepresentation> workflowRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmWorkflowsMigratePost(String realm, @Nullable @Valid String from,
       @Nullable @Valid String to) {
     return Mono.empty();
   }
 
   @Override
   public Mono<Void> adminRealmsRealmWorkflowsPost(String realm,
       @Valid Mono<WorkflowRepresentation> workflowRepresentation) {
     return Mono.empty();
   }
 
   @Override
   public Mono<WorkflowRepresentation> adminRealmsRealmWorkflowsScheduledResourceIdGet(String realm,
       String resourceId) {
     return Mono.empty();
   }
 }