View Javadoc
1   /*
2    * Copyright 2026 the original author or authors.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.bremersee.keycloak.api.webflux;
18  
19  import java.util.List;
20  import java.util.Map;
21  import org.bremersee.keycloak.api.model.AbstractPolicyRepresentation;
22  import org.bremersee.keycloak.api.model.AccessToken;
23  import org.bremersee.keycloak.api.model.AdminEventRepresentation;
24  import org.bremersee.keycloak.api.model.AuthenticationExecutionInfoRepresentation;
25  import org.bremersee.keycloak.api.model.AuthenticationExecutionRepresentation;
26  import org.bremersee.keycloak.api.model.AuthenticationFlowRepresentation;
27  import org.bremersee.keycloak.api.model.AuthenticatorConfigInfoRepresentation;
28  import org.bremersee.keycloak.api.model.AuthenticatorConfigRepresentation;
29  import org.bremersee.keycloak.api.model.CertificateRepresentation;
30  import org.bremersee.keycloak.api.model.ClientInitialAccessCreatePresentation;
31  import org.bremersee.keycloak.api.model.ClientInitialAccessPresentation;
32  import org.bremersee.keycloak.api.model.ClientPoliciesRepresentation;
33  import org.bremersee.keycloak.api.model.ClientProfilesRepresentation;
34  import org.bremersee.keycloak.api.model.ClientRepresentation;
35  import org.bremersee.keycloak.api.model.ClientScopeRepresentation;
36  import org.bremersee.keycloak.api.model.ClientTypesRepresentation;
37  import org.bremersee.keycloak.api.model.ComponentRepresentation;
38  import org.bremersee.keycloak.api.model.ComponentTypeRepresentation;
39  import org.bremersee.keycloak.api.model.ConfigPropertyRepresentation;
40  import org.bremersee.keycloak.api.model.CredentialRepresentation;
41  import org.bremersee.keycloak.api.model.EventRepresentation;
42  import org.bremersee.keycloak.api.model.FederatedIdentityRepresentation;
43  import org.bremersee.keycloak.api.model.GlobalRequestResult;
44  import org.bremersee.keycloak.api.model.GroupRepresentation;
45  import org.bremersee.keycloak.api.model.IDToken;
46  import org.bremersee.keycloak.api.model.IdentityProviderMapperRepresentation;
47  import org.bremersee.keycloak.api.model.IdentityProviderMapperTypeRepresentation;
48  import org.bremersee.keycloak.api.model.IdentityProviderRepresentation;
49  import org.bremersee.keycloak.api.model.KeyStoreConfig;
50  import org.bremersee.keycloak.api.model.KeysMetadataRepresentation;
51  import org.bremersee.keycloak.api.model.ManagementPermissionReference;
52  import org.bremersee.keycloak.api.model.MappingsRepresentation;
53  import org.bremersee.keycloak.api.model.MemberRepresentation;
54  import org.bremersee.keycloak.api.model.OrganizationInvitationRepresentation;
55  import org.bremersee.keycloak.api.model.OrganizationRepresentation;
56  import org.bremersee.keycloak.api.model.PolicyEvaluationRequest;
57  import org.bremersee.keycloak.api.model.PolicyEvaluationResponse;
58  import org.bremersee.keycloak.api.model.PolicyProviderRepresentation;
59  import org.bremersee.keycloak.api.model.PolicyRepresentation;
60  import org.bremersee.keycloak.api.model.ProtocolMapperEvaluationRepresentation;
61  import org.bremersee.keycloak.api.model.ProtocolMapperRepresentation;
62  import org.bremersee.keycloak.api.model.RealmEventsConfigRepresentation;
63  import org.bremersee.keycloak.api.model.RealmRepresentation;
64  import org.bremersee.keycloak.api.model.RequiredActionConfigInfoRepresentation;
65  import org.bremersee.keycloak.api.model.RequiredActionConfigRepresentation;
66  import org.bremersee.keycloak.api.model.RequiredActionProviderRepresentation;
67  import org.bremersee.keycloak.api.model.ResourceRepresentation;
68  import org.bremersee.keycloak.api.model.ResourceServerRepresentation;
69  import org.bremersee.keycloak.api.model.RoleRepresentation;
70  import org.bremersee.keycloak.api.model.SamlExampleResponse;
71  import org.bremersee.keycloak.api.model.ScopeRepresentation;
72  import org.bremersee.keycloak.api.model.UPConfig;
73  import org.bremersee.keycloak.api.model.UserProfileMetadata;
74  import org.bremersee.keycloak.api.model.UserRepresentation;
75  import org.bremersee.keycloak.api.model.UserSessionRepresentation;
76  import org.bremersee.keycloak.api.model.WorkflowRepresentation;
77  import org.jspecify.annotations.Nullable;
78  import org.springframework.core.io.Resource;
79  import org.springframework.validation.annotation.Validated;
80  import reactor.core.publisher.Flux;
81  import reactor.core.publisher.Mono;
82  
83  /**
84   * The admin api mock.
85   *
86   * @author Christian Bremer
87   */
88  @Validated
89  public class AdminApiMock implements AdminApi {
90  
91    /**
92     * Instantiates a new admin api mock.
93     */
94    public AdminApiMock() {
95      super();
96    }
97  
98    @Override
99    public Flux<RealmRepresentation> adminRealmsGet(Boolean briefRepresentation) {
100     return Flux.empty();
101   }
102 
103   @Override
104   public Mono<Void> adminRealmsPost(Mono<Resource> body) {
105     return Mono.empty();
106   }
107 
108   @Override
109   public Mono<Void> adminRealmsRealmAdminEventsDelete(String realm) {
110     return Mono.empty();
111   }
112 
113   @Override
114   public Flux<AdminEventRepresentation> adminRealmsRealmAdminEventsGet(String realm,
115       @Nullable String authClient, @Nullable String authIpAddress,
116       @Nullable String authRealm, @Nullable String authUser,
117       @Nullable String dateFrom, @Nullable String dateTo,
118       @Nullable String direction, @Nullable Integer first,
119       @Nullable Integer max, @Nullable List<String> operationTypes,
120       @Nullable String resourcePath, @Nullable List<String> resourceTypes) {
121     return Flux.empty();
122   }
123 
124   @Override
125   public Mono<Void> adminRealmsRealmAttackDetectionBruteForceUsersDelete(String realm) {
126     return Mono.empty();
127   }
128 
129   @Override
130   public Mono<Void> adminRealmsRealmAttackDetectionBruteForceUsersUserIdDelete(String realm,
131       String userId) {
132     return Mono.empty();
133   }
134 
135   @Override
136   public Mono<Map<String, Object>> adminRealmsRealmAttackDetectionBruteForceUsersUserIdGet(
137       String realm, String userId) {
138     return Mono.empty();
139   }
140 
141   @Override
142   public Flux<Map<String, Object>> adminRealmsRealmAuthenticationAuthenticatorProvidersGet(
143       String realm) {
144     return Flux.empty();
145   }
146 
147   @Override
148   public Flux<Map<String, Object>> adminRealmsRealmAuthenticationClientAuthenticatorProvidersGet(
149       String realm) {
150     return Flux.empty();
151   }
152 
153   @Override
154   public Mono<AuthenticatorConfigInfoRepresentation> adminRealmsRealmAuthenticationConfigDescriptionProviderIdGet(
155       String realm, String providerId) {
156     return Mono.empty();
157   }
158 
159   @Override
160   public Mono<Void> adminRealmsRealmAuthenticationConfigIdDelete(String realm, String id) {
161     return Mono.empty();
162   }
163 
164   @Override
165   public Mono<AuthenticatorConfigRepresentation> adminRealmsRealmAuthenticationConfigIdGet(
166       String realm, String id) {
167     return Mono.empty();
168   }
169 
170   @Override
171   public Mono<Void> adminRealmsRealmAuthenticationConfigIdPut(String realm, String id,
172       Mono<AuthenticatorConfigRepresentation> authenticatorConfigRepresentation) {
173     return Mono.empty();
174   }
175 
176   @Override
177   public Mono<Void> adminRealmsRealmAuthenticationConfigPost(String realm,
178       Mono<AuthenticatorConfigRepresentation> authenticatorConfigRepresentation) {
179     return Mono.empty();
180   }
181 
182   @Override
183   public Mono<AuthenticatorConfigRepresentation> adminRealmsRealmAuthenticationExecutionsExecutionIdConfigIdGet(
184       String realm, String executionId, String id) {
185     return Mono.empty();
186   }
187 
188   @Override
189   public Mono<Void> adminRealmsRealmAuthenticationExecutionsExecutionIdConfigPost(String realm,
190       String executionId,
191       Mono<AuthenticatorConfigRepresentation> authenticatorConfigRepresentation) {
192     return Mono.empty();
193   }
194 
195   @Override
196   public Mono<Void> adminRealmsRealmAuthenticationExecutionsExecutionIdDelete(String realm,
197       String executionId) {
198     return Mono.empty();
199   }
200 
201   @Override
202   public Mono<AuthenticationExecutionRepresentation> adminRealmsRealmAuthenticationExecutionsExecutionIdGet(
203       String realm, String executionId) {
204     return Mono.empty();
205   }
206 
207   @Override
208   public Mono<Void> adminRealmsRealmAuthenticationExecutionsExecutionIdLowerPriorityPost(
209       String realm, String executionId) {
210     return Mono.empty();
211   }
212 
213   @Override
214   public Mono<Void> adminRealmsRealmAuthenticationExecutionsExecutionIdRaisePriorityPost(
215       String realm, String executionId) {
216     return Mono.empty();
217   }
218 
219   @Override
220   public Mono<Void> adminRealmsRealmAuthenticationExecutionsPost(String realm,
221       Mono<AuthenticationExecutionRepresentation> authenticationExecutionRepresentation) {
222     return Mono.empty();
223   }
224 
225   @Override
226   public Mono<Void> adminRealmsRealmAuthenticationFlowsFlowAliasCopyPost(String realm,
227       String flowAlias, Mono<Map<String, String>> requestBody) {
228     return Mono.empty();
229   }
230 
231   @Override
232   public Mono<Void> adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsExecutionPost(
233       String realm, String flowAlias, Mono<Map<String, Object>> requestBody) {
234     return Mono.empty();
235   }
236 
237   @Override
238   public Mono<Void> adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsFlowPost(String realm,
239       String flowAlias, Mono<Map<String, Object>> requestBody) {
240     return Mono.empty();
241   }
242 
243   @Override
244   public Flux<AuthenticationExecutionInfoRepresentation> adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsGet(
245       String realm, String flowAlias) {
246     return Flux.empty();
247   }
248 
249   @Override
250   public Mono<Void> adminRealmsRealmAuthenticationFlowsFlowAliasExecutionsPut(String realm,
251       String flowAlias,
252       Mono<AuthenticationExecutionInfoRepresentation> authenticationExecutionInfoRepresentation) {
253     return Mono.empty();
254   }
255 
256   @Override
257   public Flux<AuthenticationFlowRepresentation> adminRealmsRealmAuthenticationFlowsGet(
258       String realm) {
259     return Flux.empty();
260   }
261 
262   @Override
263   public Mono<Void> adminRealmsRealmAuthenticationFlowsIdDelete(String realm, String id) {
264     return Mono.empty();
265   }
266 
267   @Override
268   public Mono<AuthenticationFlowRepresentation> adminRealmsRealmAuthenticationFlowsIdGet(
269       String realm, String id) {
270     return Mono.empty();
271   }
272 
273   @Override
274   public Mono<Void> adminRealmsRealmAuthenticationFlowsIdPut(String realm, String id,
275       Mono<AuthenticationFlowRepresentation> authenticationFlowRepresentation) {
276     return Mono.empty();
277   }
278 
279   @Override
280   public Mono<Void> adminRealmsRealmAuthenticationFlowsPost(String realm,
281       Mono<AuthenticationFlowRepresentation> authenticationFlowRepresentation) {
282     return Mono.empty();
283   }
284 
285   @Override
286   public Flux<Map<String, Object>> adminRealmsRealmAuthenticationFormActionProvidersGet(
287       String realm) {
288     return Flux.empty();
289   }
290 
291   @Override
292   public Flux<Map<String, Object>> adminRealmsRealmAuthenticationFormProvidersGet(String realm) {
293     return Flux.empty();
294   }
295 
296   @Override
297   public Mono<Map<String, List<ConfigPropertyRepresentation>>> adminRealmsRealmAuthenticationPerClientConfigDescriptionGet(
298       String realm) {
299     return Mono.empty();
300   }
301 
302   @Override
303   public Mono<Void> adminRealmsRealmAuthenticationRegisterRequiredActionPost(String realm,
304       Mono<Map<String, String>> requestBody) {
305     return Mono.empty();
306   }
307 
308   @Override
309   public Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasConfigDelete(String realm,
310       String alias) {
311     return Mono.empty();
312   }
313 
314   @Override
315   public Mono<RequiredActionConfigInfoRepresentation> adminRealmsRealmAuthenticationRequiredActionsAliasConfigDescriptionGet(
316       String realm, String alias) {
317     return Mono.empty();
318   }
319 
320   @Override
321   public Mono<RequiredActionConfigRepresentation> adminRealmsRealmAuthenticationRequiredActionsAliasConfigGet(
322       String realm, String alias) {
323     return Mono.empty();
324   }
325 
326   @Override
327   public Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasConfigPut(String realm,
328       String alias,
329       Mono<RequiredActionConfigRepresentation> requiredActionConfigRepresentation) {
330     return Mono.empty();
331   }
332 
333   @Override
334   public Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasDelete(String realm,
335       String alias) {
336     return Mono.empty();
337   }
338 
339   @Override
340   public Mono<RequiredActionProviderRepresentation> adminRealmsRealmAuthenticationRequiredActionsAliasGet(
341       String realm, String alias) {
342     return Mono.empty();
343   }
344 
345   @Override
346   public Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasLowerPriorityPost(
347       String realm, String alias) {
348     return Mono.empty();
349   }
350 
351   @Override
352   public Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasPut(String realm,
353       String alias,
354       Mono<RequiredActionProviderRepresentation> requiredActionProviderRepresentation) {
355     return Mono.empty();
356   }
357 
358   @Override
359   public Mono<Void> adminRealmsRealmAuthenticationRequiredActionsAliasRaisePriorityPost(
360       String realm, String alias) {
361     return Mono.empty();
362   }
363 
364   @Override
365   public Flux<RequiredActionProviderRepresentation> adminRealmsRealmAuthenticationRequiredActionsGet(
366       String realm) {
367     return Flux.empty();
368   }
369 
370   @Override
371   public Flux<Map<String, String>> adminRealmsRealmAuthenticationUnregisteredRequiredActionsGet(
372       String realm) {
373     return Flux.empty();
374   }
375 
376   @Override
377   public Mono<ClientRepresentation> adminRealmsRealmClientDescriptionConverterPost(String realm,
378       Mono<String> body) {
379     return Mono.empty();
380   }
381 
382   @Override
383   public Mono<ClientPoliciesRepresentation> adminRealmsRealmClientPoliciesPoliciesGet(String realm,
384       @Nullable Boolean includeGlobalPolicies) {
385     return Mono.empty();
386   }
387 
388   @Override
389   public Mono<Void> adminRealmsRealmClientPoliciesPoliciesPut(String realm,
390       Mono<ClientPoliciesRepresentation> clientPoliciesRepresentation) {
391     return Mono.empty();
392   }
393 
394   @Override
395   public Mono<ClientProfilesRepresentation> adminRealmsRealmClientPoliciesProfilesGet(String realm,
396       @Nullable Boolean includeGlobalProfiles) {
397     return Mono.empty();
398   }
399 
400   @Override
401   public Mono<Void> adminRealmsRealmClientPoliciesProfilesPut(String realm,
402       Mono<ClientProfilesRepresentation> clientProfilesRepresentation) {
403     return Mono.empty();
404   }
405 
406   @Override
407   public Flux<ComponentTypeRepresentation> adminRealmsRealmClientRegistrationPolicyProvidersGet(
408       String realm) {
409     return Flux.empty();
410   }
411 
412   @Override
413   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdDelete(String realm,
414       String clientScopeId) {
415     return Mono.empty();
416   }
417 
418   @Override
419   public Mono<ClientScopeRepresentation> adminRealmsRealmClientScopesClientScopeIdGet(String realm,
420       String clientScopeId) {
421     return Mono.empty();
422   }
423 
424   @Override
425   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdProtocolMappersAddModelsPost(
426       String realm, String clientScopeId,
427       Flux<ProtocolMapperRepresentation> protocolMapperRepresentation) {
428     return Mono.empty();
429   }
430 
431   @Override
432   public Flux<ProtocolMapperRepresentation> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsGet(
433       String realm, String clientScopeId) {
434     return Flux.empty();
435   }
436 
437   @Override
438   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdDelete(
439       String realm, String clientScopeId, String id) {
440     return Mono.empty();
441   }
442 
443   @Override
444   public Mono<ProtocolMapperRepresentation> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdGet(
445       String realm, String clientScopeId, String id) {
446     return Mono.empty();
447   }
448 
449   @Override
450   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsIdPut(
451       String realm, String clientScopeId, String id,
452       Mono<ProtocolMapperRepresentation> protocolMapperRepresentation) {
453     return Mono.empty();
454   }
455 
456   @Override
457   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdProtocolMappersModelsPost(String realm,
458       String clientScopeId,
459       Mono<ProtocolMapperRepresentation> protocolMapperRepresentation) {
460     return Mono.empty();
461   }
462 
463   @Override
464   public Flux<ProtocolMapperRepresentation> adminRealmsRealmClientScopesClientScopeIdProtocolMappersProtocolProtocolGet(
465       String realm, String clientScopeId, String protocol) {
466     return Flux.empty();
467   }
468 
469   @Override
470   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdPut(String realm, String clientScopeId,
471       Mono<ClientScopeRepresentation> clientScopeRepresentation) {
472     return Mono.empty();
473   }
474 
475   @Override
476   public Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientAvailableGet(
477       String realm, String clientScopeId, String client) {
478     return Flux.empty();
479   }
480 
481   @Override
482   public Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientCompositeGet(
483       String realm, String clientScopeId, String client, Boolean briefRepresentation) {
484     return Flux.empty();
485   }
486 
487   @Override
488   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientDelete(
489       String realm, String clientScopeId, String client,
490       Flux<RoleRepresentation> roleRepresentation) {
491     return Mono.empty();
492   }
493 
494   @Override
495   public Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientGet(
496       String realm, String clientScopeId, String client) {
497     return Flux.empty();
498   }
499 
500   @Override
501   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdScopeMappingsClientsClientPost(
502       String realm, String clientScopeId, String client,
503       Flux<RoleRepresentation> roleRepresentation) {
504     return Mono.empty();
505   }
506 
507   @Override
508   public Mono<MappingsRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsGet(
509       String realm, String clientScopeId) {
510     return Mono.empty();
511   }
512 
513   @Override
514   public Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmAvailableGet(
515       String realm, String clientScopeId) {
516     return Flux.empty();
517   }
518 
519   @Override
520   public Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmCompositeGet(
521       String realm, String clientScopeId, Boolean briefRepresentation) {
522     return Flux.empty();
523   }
524 
525   @Override
526   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmDelete(String realm,
527       String clientScopeId, Flux<RoleRepresentation> roleRepresentation) {
528     return Mono.empty();
529   }
530 
531   @Override
532   public Flux<RoleRepresentation> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmGet(
533       String realm, String clientScopeId) {
534     return Flux.empty();
535   }
536 
537   @Override
538   public Mono<Void> adminRealmsRealmClientScopesClientScopeIdScopeMappingsRealmPost(String realm,
539       String clientScopeId, Flux<RoleRepresentation> roleRepresentation) {
540     return Mono.empty();
541   }
542 
543   @Override
544   public Flux<ClientScopeRepresentation> adminRealmsRealmClientScopesGet(String realm) {
545     return Flux.empty();
546   }
547 
548   @Override
549   public Mono<Void> adminRealmsRealmClientScopesPost(String realm,
550       Mono<ClientScopeRepresentation> clientScopeRepresentation) {
551     return Mono.empty();
552   }
553 
554   @Override
555   public Flux<Map<String, String>> adminRealmsRealmClientSessionStatsGet(String realm) {
556     return Flux.empty();
557   }
558 
559   @Override
560   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdDelete(String realm,
561       String clientScopeId) {
562     return Mono.empty();
563   }
564 
565   @Override
566   public Mono<ClientScopeRepresentation> adminRealmsRealmClientTemplatesClientScopeIdGet(
567       String realm, String clientScopeId) {
568     return Mono.empty();
569   }
570 
571   @Override
572   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersAddModelsPost(
573       String realm, String clientScopeId,
574       Flux<ProtocolMapperRepresentation> protocolMapperRepresentation) {
575     return Mono.empty();
576   }
577 
578   @Override
579   public Flux<ProtocolMapperRepresentation> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsGet(
580       String realm, String clientScopeId) {
581     return Flux.empty();
582   }
583 
584   @Override
585   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdDelete(
586       String realm, String clientScopeId, String id) {
587     return Mono.empty();
588   }
589 
590   @Override
591   public Mono<ProtocolMapperRepresentation> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdGet(
592       String realm, String clientScopeId, String id) {
593     return Mono.empty();
594   }
595 
596   @Override
597   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsIdPut(
598       String realm, String clientScopeId, String id,
599       Mono<ProtocolMapperRepresentation> protocolMapperRepresentation) {
600     return Mono.empty();
601   }
602 
603   @Override
604   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersModelsPost(
605       String realm, String clientScopeId,
606       Mono<ProtocolMapperRepresentation> protocolMapperRepresentation) {
607     return Mono.empty();
608   }
609 
610   @Override
611   public Flux<ProtocolMapperRepresentation> adminRealmsRealmClientTemplatesClientScopeIdProtocolMappersProtocolProtocolGet(
612       String realm, String clientScopeId, String protocol) {
613     return Flux.empty();
614   }
615 
616   @Override
617   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdPut(String realm,
618       String clientScopeId, Mono<ClientScopeRepresentation> clientScopeRepresentation) {
619     return Mono.empty();
620   }
621 
622   @Override
623   public Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientAvailableGet(
624       String realm, String clientScopeId, String client) {
625     return Flux.empty();
626   }
627 
628   @Override
629   public Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientCompositeGet(
630       String realm, String clientScopeId, String client, Boolean briefRepresentation) {
631     return Flux.empty();
632   }
633 
634   @Override
635   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientDelete(
636       String realm, String clientScopeId, String client,
637       Flux<RoleRepresentation> roleRepresentation) {
638     return Mono.empty();
639   }
640 
641   @Override
642   public Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientGet(
643       String realm, String clientScopeId, String client) {
644     return Flux.empty();
645   }
646 
647   @Override
648   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsClientsClientPost(
649       String realm, String clientScopeId, String client,
650       Flux<RoleRepresentation> roleRepresentation) {
651     return Mono.empty();
652   }
653 
654   @Override
655   public Mono<MappingsRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsGet(
656       String realm, String clientScopeId) {
657     return Mono.empty();
658   }
659 
660   @Override
661   public Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmAvailableGet(
662       String realm, String clientScopeId) {
663     return Flux.empty();
664   }
665 
666   @Override
667   public Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmCompositeGet(
668       String realm, String clientScopeId, Boolean briefRepresentation) {
669     return Flux.empty();
670   }
671 
672   @Override
673   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmDelete(
674       String realm, String clientScopeId, Flux<RoleRepresentation> roleRepresentation) {
675     return Mono.empty();
676   }
677 
678   @Override
679   public Flux<RoleRepresentation> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmGet(
680       String realm, String clientScopeId) {
681     return Flux.empty();
682   }
683 
684   @Override
685   public Mono<Void> adminRealmsRealmClientTemplatesClientScopeIdScopeMappingsRealmPost(String realm,
686       String clientScopeId, Flux<RoleRepresentation> roleRepresentation) {
687     return Mono.empty();
688   }
689 
690   @Override
691   public Flux<ClientScopeRepresentation> adminRealmsRealmClientTemplatesGet(String realm) {
692     return Flux.empty();
693   }
694 
695   @Override
696   public Mono<Void> adminRealmsRealmClientTemplatesPost(String realm,
697       Mono<ClientScopeRepresentation> clientScopeRepresentation) {
698     return Mono.empty();
699   }
700 
701   @Override
702   public Mono<ClientTypesRepresentation> adminRealmsRealmClientTypesGet(String realm) {
703     return Mono.empty();
704   }
705 
706   @Override
707   public Mono<Void> adminRealmsRealmClientTypesPut(String realm,
708       Mono<ClientTypesRepresentation> clientTypesRepresentation) {
709     return Mono.empty();
710   }
711 
712   @Override
713   public Mono<ResourceServerRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerGet(
714       String realm, String clientUuid) {
715     return Mono.empty();
716   }
717 
718   @Override
719   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerImportPost(String realm,
720       String clientUuid, Mono<ResourceServerRepresentation> resourceServerRepresentation) {
721     return Mono.empty();
722   }
723 
724   @Override
725   public Mono<PolicyEvaluationResponse> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionEvaluatePost(
726       String realm, String clientUuid,
727       Mono<PolicyEvaluationRequest> policyEvaluationRequest) {
728     return Mono.empty();
729   }
730 
731   @Override
732   public Flux<AbstractPolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionGet(
733       String realm, String clientUuid, @Nullable String fields,
734       @Nullable Integer first, @Nullable Integer max, @Nullable String name,
735       @Nullable String owner, @Nullable Boolean permission,
736       @Nullable String policyId, @Nullable String resource,
737       @Nullable String resourceType, @Nullable String scope,
738       @Nullable String type) {
739     return Flux.empty();
740   }
741 
742   @Override
743   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionPost(String realm,
744       String clientUuid, Mono<String> body) {
745     return Mono.empty();
746   }
747 
748   @Override
749   public Flux<PolicyProviderRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionProvidersGet(
750       String realm, String clientUuid) {
751     return Flux.empty();
752   }
753 
754   @Override
755   public Mono<AbstractPolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPermissionSearchGet(
756       String realm, String clientUuid, @Nullable String fields,
757       @Nullable String name) {
758     return Mono.empty();
759   }
760 
761   @Override
762   public Mono<PolicyEvaluationResponse> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyEvaluatePost(
763       String realm, String clientUuid,
764       Mono<PolicyEvaluationRequest> policyEvaluationRequest) {
765     return Mono.empty();
766   }
767 
768   @Override
769   public Flux<AbstractPolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyGet(
770       String realm, String clientUuid, @Nullable String fields,
771       @Nullable Integer first, @Nullable Integer max, @Nullable String name,
772       @Nullable String owner, @Nullable Boolean permission,
773       @Nullable String policyId, @Nullable String resource,
774       @Nullable String resourceType, @Nullable String scope,
775       @Nullable String type) {
776     return Flux.empty();
777   }
778 
779   @Override
780   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyPost(String realm,
781       String clientUuid, Mono<String> body) {
782     return Mono.empty();
783   }
784 
785   @Override
786   public Flux<PolicyProviderRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicyProvidersGet(
787       String realm, String clientUuid) {
788     return Flux.empty();
789   }
790 
791   @Override
792   public Mono<AbstractPolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerPolicySearchGet(
793       String realm, String clientUuid, @Nullable String fields,
794       @Nullable String name) {
795     return Mono.empty();
796   }
797 
798   @Override
799   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerPut(String realm,
800       String clientUuid, Mono<ResourceServerRepresentation> resourceServerRepresentation) {
801     return Mono.empty();
802   }
803 
804   @Override
805   public Flux<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceGet(
806       String realm, String clientUuid, @Nullable String id, @Nullable Boolean deep,
807       @Nullable Boolean exactName, @Nullable Integer first,
808       @Nullable Boolean matchingUri, @Nullable Integer max,
809       @Nullable String name, @Nullable String owner, @Nullable String scope,
810       @Nullable String type, @Nullable String uri) {
811     return Flux.empty();
812   }
813 
814   @Override
815   public Mono<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourcePost(
816       String realm, String clientUuid, @Nullable String id, @Nullable Boolean deep,
817       @Nullable Boolean exactName, @Nullable Integer first,
818       @Nullable Boolean matchingUri, @Nullable Integer max,
819       @Nullable String name, @Nullable String owner, @Nullable String scope,
820       @Nullable String type, @Nullable String uri,
821       Mono<ResourceRepresentation> resourceRepresentation) {
822     return Mono.empty();
823   }
824 
825   @Override
826   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdAttributesGet(
827       String realm, String clientUuid, String resourceId, @Nullable String id,
828       @Nullable Boolean deep, @Nullable Boolean exactName,
829       @Nullable Integer first, @Nullable Boolean matchingUri,
830       @Nullable Integer max, @Nullable String name, @Nullable String owner,
831       @Nullable String scope, @Nullable String type, @Nullable String uri) {
832     return Mono.empty();
833   }
834 
835   @Override
836   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdDelete(
837       String realm, String clientUuid, String resourceId, @Nullable String id,
838       @Nullable Boolean deep, @Nullable Boolean exactName,
839       @Nullable Integer first, @Nullable Boolean matchingUri,
840       @Nullable Integer max, @Nullable String name, @Nullable String owner,
841       @Nullable String scope, @Nullable String type, @Nullable String uri) {
842     return Mono.empty();
843   }
844 
845   @Override
846   public Mono<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdGet(
847       String realm, String clientUuid, String resourceId, @Nullable String id,
848       @Nullable Boolean deep, @Nullable Boolean exactName,
849       @Nullable Integer first, @Nullable Boolean matchingUri,
850       @Nullable Integer max, @Nullable String name, @Nullable String owner,
851       @Nullable String scope, @Nullable String type, @Nullable String uri) {
852     return Mono.empty();
853   }
854 
855   @Override
856   public Flux<PolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdPermissionsGet(
857       String realm, String clientUuid, String resourceId, @Nullable String id,
858       @Nullable Boolean deep, @Nullable Boolean exactName,
859       @Nullable Integer first, @Nullable Boolean matchingUri,
860       @Nullable Integer max, @Nullable String name, @Nullable String owner,
861       @Nullable String scope, @Nullable String type, @Nullable String uri) {
862     return Flux.empty();
863   }
864 
865   @Override
866   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdPut(
867       String realm, String clientUuid, String resourceId, @Nullable String id,
868       @Nullable Boolean deep, @Nullable Boolean exactName,
869       @Nullable Integer first, @Nullable Boolean matchingUri,
870       @Nullable Integer max, @Nullable String name, @Nullable String owner,
871       @Nullable String scope, @Nullable String type, @Nullable String uri,
872       Mono<ResourceRepresentation> resourceRepresentation) {
873     return Mono.empty();
874   }
875 
876   @Override
877   public Flux<ScopeRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceResourceIdScopesGet(
878       String realm, String clientUuid, String resourceId, @Nullable String id,
879       @Nullable Boolean deep, @Nullable Boolean exactName,
880       @Nullable Integer first, @Nullable Boolean matchingUri,
881       @Nullable Integer max, @Nullable String name, @Nullable String owner,
882       @Nullable String scope, @Nullable String type, @Nullable String uri) {
883     return Flux.empty();
884   }
885 
886   @Override
887   public Mono<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerResourceSearchGet(
888       String realm, String clientUuid, @Nullable String id, @Nullable Boolean deep,
889       @Nullable Boolean exactName, @Nullable Integer first,
890       @Nullable Boolean matchingUri, @Nullable Integer max,
891       @Nullable String owner, @Nullable String scope, @Nullable String type,
892       @Nullable String uri, @Nullable String name) {
893     return Mono.empty();
894   }
895 
896   @Override
897   public Flux<ScopeRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeGet(
898       String realm, String clientUuid, @Nullable Integer first, @Nullable Integer max,
899       @Nullable String name, @Nullable String scopeId) {
900     return Flux.empty();
901   }
902 
903   @Override
904   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerScopePost(String realm,
905       String clientUuid, Mono<ScopeRepresentation> scopeRepresentation) {
906     return Mono.empty();
907   }
908 
909   @Override
910   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdDelete(
911       String realm, String clientUuid, String scopeId) {
912     return Mono.empty();
913   }
914 
915   @Override
916   public Mono<ScopeRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdGet(
917       String realm, String clientUuid, String scopeId) {
918     return Mono.empty();
919   }
920 
921   @Override
922   public Flux<PolicyRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdPermissionsGet(
923       String realm, String clientUuid, String scopeId) {
924     return Flux.empty();
925   }
926 
927   @Override
928   public Mono<Void> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdPut(
929       String realm, String clientUuid, String scopeId,
930       Mono<ScopeRepresentation> scopeRepresentation) {
931     return Mono.empty();
932   }
933 
934   @Override
935   public Flux<ResourceRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeScopeIdResourcesGet(
936       String realm, String clientUuid, String scopeId) {
937     return Flux.empty();
938   }
939 
940   @Override
941   public Flux<ScopeRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerScopeSearchGet(
942       String realm, String clientUuid, @Nullable String name) {
943     return Flux.empty();
944   }
945 
946   @Override
947   public Mono<ResourceServerRepresentation> adminRealmsRealmClientsClientUuidAuthzResourceServerSettingsGet(
948       String realm, String clientUuid) {
949     return Mono.empty();
950   }
951 
952   @Override
953   public Mono<Resource> adminRealmsRealmClientsClientUuidCertificatesAttrDownloadPost(String realm,
954       String clientUuid, String attr, Mono<KeyStoreConfig> keyStoreConfig) {
955     return Mono.empty();
956   }
957 
958   @Override
959   public Mono<Resource> adminRealmsRealmClientsClientUuidCertificatesAttrGenerateAndDownloadPost(
960       String realm, String clientUuid, String attr, Mono<KeyStoreConfig> keyStoreConfig) {
961     return Mono.empty();
962   }
963 
964   @Override
965   public Mono<CertificateRepresentation> adminRealmsRealmClientsClientUuidCertificatesAttrGeneratePost(
966       String realm, String clientUuid, String attr) {
967     return Mono.empty();
968   }
969 
970   @Override
971   public Mono<CertificateRepresentation> adminRealmsRealmClientsClientUuidCertificatesAttrGet(
972       String realm, String clientUuid, String attr) {
973     return Mono.empty();
974   }
975 
976   @Override
977   public Mono<CertificateRepresentation> adminRealmsRealmClientsClientUuidCertificatesAttrUploadCertificatePost(
978       String realm, String clientUuid, String attr) {
979     return Mono.empty();
980   }
981 
982   @Override
983   public Mono<CertificateRepresentation> adminRealmsRealmClientsClientUuidCertificatesAttrUploadPost(
984       String realm, String clientUuid, String attr) {
985     return Mono.empty();
986   }
987 
988   @Override
989   public Mono<CredentialRepresentation> adminRealmsRealmClientsClientUuidClientSecretGet(
990       String realm, String clientUuid) {
991     return Mono.empty();
992   }
993 
994   @Override
995   public Mono<CredentialRepresentation> adminRealmsRealmClientsClientUuidClientSecretPost(
996       String realm, String clientUuid) {
997     return Mono.empty();
998   }
999 
1000   @Override
1001   public Mono<Void> adminRealmsRealmClientsClientUuidClientSecretRotatedDelete(String realm,
1002       String clientUuid) {
1003     return Mono.empty();
1004   }
1005 
1006   @Override
1007   public Mono<CredentialRepresentation> adminRealmsRealmClientsClientUuidClientSecretRotatedGet(
1008       String realm, String clientUuid) {
1009     return Mono.empty();
1010   }
1011 
1012   @Override
1013   public Mono<Void> adminRealmsRealmClientsClientUuidDefaultClientScopesClientScopeIdDelete(
1014       String realm, String clientUuid, String clientScopeId) {
1015     return Mono.empty();
1016   }
1017 
1018   @Override
1019   public Mono<Void> adminRealmsRealmClientsClientUuidDefaultClientScopesClientScopeIdPut(
1020       String realm, String clientUuid, String clientScopeId) {
1021     return Mono.empty();
1022   }
1023 
1024   @Override
1025   public Flux<ClientScopeRepresentation> adminRealmsRealmClientsClientUuidDefaultClientScopesGet(
1026       String realm, String clientUuid) {
1027     return Flux.empty();
1028   }
1029 
1030   @Override
1031   public Mono<Void> adminRealmsRealmClientsClientUuidDelete(String realm, String clientUuid) {
1032     return Mono.empty();
1033   }
1034 
1035   @Override
1036   public Mono<AccessToken> adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleAccessTokenGet(
1037       String realm, String clientUuid, @Nullable String audience,
1038       @Nullable String scope, @Nullable String userId) {
1039     return Mono.empty();
1040   }
1041 
1042   @Override
1043   public Mono<IDToken> adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleIdTokenGet(
1044       String realm, String clientUuid, @Nullable String audience,
1045       @Nullable String scope, @Nullable String userId) {
1046     return Mono.empty();
1047   }
1048 
1049   @Override
1050   public Mono<SamlExampleResponse> adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleSamlResponseGet(
1051       String realm, String clientUuid, @Nullable String audience,
1052       @Nullable String scope, @Nullable String userId) {
1053     return Mono.empty();
1054   }
1055 
1056   @Override
1057   public Mono<Object> adminRealmsRealmClientsClientUuidEvaluateScopesGenerateExampleUserinfoGet(
1058       String realm, String clientUuid, @Nullable String scope,
1059       @Nullable String userId) {
1060     return Mono.empty();
1061   }
1062 
1063   @Override
1064   public Flux<ProtocolMapperEvaluationRepresentation> adminRealmsRealmClientsClientUuidEvaluateScopesProtocolMappersGet(
1065       String realm, String clientUuid, @Nullable String scope) {
1066     return Flux.empty();
1067   }
1068 
1069   @Override
1070   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidEvaluateScopesScopeMappingsRoleContainerIdGrantedGet(
1071       String realm, String clientUuid, String roleContainerId, @Nullable String scope) {
1072     return Flux.empty();
1073   }
1074 
1075   @Override
1076   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidEvaluateScopesScopeMappingsRoleContainerIdNotGrantedGet(
1077       String realm, String clientUuid, String roleContainerId, @Nullable String scope) {
1078     return Flux.empty();
1079   }
1080 
1081   @Override
1082   public Mono<ClientRepresentation> adminRealmsRealmClientsClientUuidGet(String realm,
1083       String clientUuid) {
1084     return Mono.empty();
1085   }
1086 
1087   @Override
1088   public Mono<Void> adminRealmsRealmClientsClientUuidInstallationProvidersProviderIdGet(
1089       String realm, String clientUuid, String providerId) {
1090     return Mono.empty();
1091   }
1092 
1093   @Override
1094   public Mono<ManagementPermissionReference> adminRealmsRealmClientsClientUuidManagementPermissionsGet(
1095       String realm, String clientUuid) {
1096     return Mono.empty();
1097   }
1098 
1099   @Override
1100   public Mono<ManagementPermissionReference> adminRealmsRealmClientsClientUuidManagementPermissionsPut(
1101       String realm, String clientUuid,
1102       Mono<ManagementPermissionReference> managementPermissionReference) {
1103     return Mono.empty();
1104   }
1105 
1106   @Override
1107   public Mono<Void> adminRealmsRealmClientsClientUuidNodesNodeDelete(String realm,
1108       String clientUuid, String node) {
1109     return Mono.empty();
1110   }
1111 
1112   @Override
1113   public Mono<Void> adminRealmsRealmClientsClientUuidNodesPost(String realm, String clientUuid,
1114       Mono<Map<String, String>> requestBody) {
1115     return Mono.empty();
1116   }
1117 
1118   @Override
1119   public Mono<Map<String, Long>> adminRealmsRealmClientsClientUuidOfflineSessionCountGet(
1120       String realm, String clientUuid) {
1121     return Mono.empty();
1122   }
1123 
1124   @Override
1125   public Flux<UserSessionRepresentation> adminRealmsRealmClientsClientUuidOfflineSessionsGet(
1126       String realm, String clientUuid, @Nullable Integer first,
1127       @Nullable Integer max) {
1128     return Flux.empty();
1129   }
1130 
1131   @Override
1132   public Mono<Void> adminRealmsRealmClientsClientUuidOptionalClientScopesClientScopeIdDelete(
1133       String realm, String clientUuid, String clientScopeId) {
1134     return Mono.empty();
1135   }
1136 
1137   @Override
1138   public Mono<Void> adminRealmsRealmClientsClientUuidOptionalClientScopesClientScopeIdPut(
1139       String realm, String clientUuid, String clientScopeId) {
1140     return Mono.empty();
1141   }
1142 
1143   @Override
1144   public Flux<ClientScopeRepresentation> adminRealmsRealmClientsClientUuidOptionalClientScopesGet(
1145       String realm, String clientUuid) {
1146     return Flux.empty();
1147   }
1148 
1149   @Override
1150   public Mono<Void> adminRealmsRealmClientsClientUuidProtocolMappersAddModelsPost(String realm,
1151       String clientUuid, Flux<ProtocolMapperRepresentation> protocolMapperRepresentation) {
1152     return Mono.empty();
1153   }
1154 
1155   @Override
1156   public Flux<ProtocolMapperRepresentation> adminRealmsRealmClientsClientUuidProtocolMappersModelsGet(
1157       String realm, String clientUuid) {
1158     return Flux.empty();
1159   }
1160 
1161   @Override
1162   public Mono<Void> adminRealmsRealmClientsClientUuidProtocolMappersModelsIdDelete(String realm,
1163       String clientUuid, String id) {
1164     return Mono.empty();
1165   }
1166 
1167   @Override
1168   public Mono<ProtocolMapperRepresentation> adminRealmsRealmClientsClientUuidProtocolMappersModelsIdGet(
1169       String realm, String clientUuid, String id) {
1170     return Mono.empty();
1171   }
1172 
1173   @Override
1174   public Mono<Void> adminRealmsRealmClientsClientUuidProtocolMappersModelsIdPut(String realm,
1175       String clientUuid, String id,
1176       Mono<ProtocolMapperRepresentation> protocolMapperRepresentation) {
1177     return Mono.empty();
1178   }
1179 
1180   @Override
1181   public Mono<Void> adminRealmsRealmClientsClientUuidProtocolMappersModelsPost(String realm,
1182       String clientUuid, Mono<ProtocolMapperRepresentation> protocolMapperRepresentation) {
1183     return Mono.empty();
1184   }
1185 
1186   @Override
1187   public Flux<ProtocolMapperRepresentation> adminRealmsRealmClientsClientUuidProtocolMappersProtocolProtocolGet(
1188       String realm, String clientUuid, String protocol) {
1189     return Flux.empty();
1190   }
1191 
1192   @Override
1193   public Mono<GlobalRequestResult> adminRealmsRealmClientsClientUuidPushRevocationPost(String realm,
1194       String clientUuid) {
1195     return Mono.empty();
1196   }
1197 
1198   @Override
1199   public Mono<Void> adminRealmsRealmClientsClientUuidPut(String realm, String clientUuid,
1200       Mono<ClientRepresentation> clientRepresentation) {
1201     return Mono.empty();
1202   }
1203 
1204   @Override
1205   public Mono<ClientRepresentation> adminRealmsRealmClientsClientUuidRegistrationAccessTokenPost(
1206       String realm, String clientUuid) {
1207     return Mono.empty();
1208   }
1209 
1210   @Override
1211   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesGet(String realm,
1212       String clientUuid, Boolean briefRepresentation, @Nullable Integer first,
1213       @Nullable Integer max, String search) {
1214     return Flux.empty();
1215   }
1216 
1217   @Override
1218   public Mono<Void> adminRealmsRealmClientsClientUuidRolesPost(String realm, String clientUuid,
1219       Mono<RoleRepresentation> roleRepresentation) {
1220     return Mono.empty();
1221   }
1222 
1223   @Override
1224   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesClientsTargetClientUuidGet(
1225       String realm, String clientUuid, String roleName, String targetClientUuid) {
1226     return Flux.empty();
1227   }
1228 
1229   @Override
1230   public Mono<Void> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesDelete(String realm,
1231       String clientUuid, String roleName, Flux<RoleRepresentation> roleRepresentation) {
1232     return Mono.empty();
1233   }
1234 
1235   @Override
1236   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesGet(
1237       String realm, String clientUuid, String roleName) {
1238     return Flux.empty();
1239   }
1240 
1241   @Override
1242   public Mono<Void> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesPost(String realm,
1243       String clientUuid, String roleName, Flux<RoleRepresentation> roleRepresentation) {
1244     return Mono.empty();
1245   }
1246 
1247   @Override
1248   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameCompositesRealmGet(
1249       String realm, String clientUuid, String roleName) {
1250     return Flux.empty();
1251   }
1252 
1253   @Override
1254   public Mono<Void> adminRealmsRealmClientsClientUuidRolesRoleNameDelete(String realm,
1255       String clientUuid, String roleName) {
1256     return Mono.empty();
1257   }
1258 
1259   @Override
1260   public Mono<RoleRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameGet(String realm,
1261       String clientUuid, String roleName) {
1262     return Mono.empty();
1263   }
1264 
1265   @Override
1266   public Flux<UserRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameGroupsGet(
1267       String realm, String clientUuid, String roleName, @Nullable Integer max,
1268       Boolean briefRepresentation, @Nullable Integer first) {
1269     return Flux.empty();
1270   }
1271 
1272   @Override
1273   public Mono<ManagementPermissionReference> adminRealmsRealmClientsClientUuidRolesRoleNameManagementPermissionsGet(
1274       String realm, String clientUuid, String roleName) {
1275     return Mono.empty();
1276   }
1277 
1278   @Override
1279   public Mono<ManagementPermissionReference> adminRealmsRealmClientsClientUuidRolesRoleNameManagementPermissionsPut(
1280       String realm, String clientUuid, String roleName,
1281       Mono<ManagementPermissionReference> managementPermissionReference) {
1282     return Mono.empty();
1283   }
1284 
1285   @Override
1286   public Mono<Void> adminRealmsRealmClientsClientUuidRolesRoleNamePut(String realm,
1287       String clientUuid, String roleName, Mono<RoleRepresentation> roleRepresentation) {
1288     return Mono.empty();
1289   }
1290 
1291   @Override
1292   public Flux<UserRepresentation> adminRealmsRealmClientsClientUuidRolesRoleNameUsersGet(
1293       String realm, String clientUuid, String roleName,
1294       @Nullable Boolean briefRepresentation, @Nullable Integer first,
1295       @Nullable Integer max) {
1296     return Flux.empty();
1297   }
1298 
1299   @Override
1300   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientAvailableGet(
1301       String realm, String clientUuid, String client) {
1302     return Flux.empty();
1303   }
1304 
1305   @Override
1306   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientCompositeGet(
1307       String realm, String clientUuid, String client, Boolean briefRepresentation) {
1308     return Flux.empty();
1309   }
1310 
1311   @Override
1312   public Mono<Void> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientDelete(String realm,
1313       String clientUuid, String client, Flux<RoleRepresentation> roleRepresentation) {
1314     return Mono.empty();
1315   }
1316 
1317   @Override
1318   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientGet(
1319       String realm, String clientUuid, String client) {
1320     return Flux.empty();
1321   }
1322 
1323   @Override
1324   public Mono<Void> adminRealmsRealmClientsClientUuidScopeMappingsClientsClientPost(String realm,
1325       String clientUuid, String client, Flux<RoleRepresentation> roleRepresentation) {
1326     return Mono.empty();
1327   }
1328 
1329   @Override
1330   public Mono<MappingsRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsGet(
1331       String realm, String clientUuid) {
1332     return Mono.empty();
1333   }
1334 
1335   @Override
1336   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsRealmAvailableGet(
1337       String realm, String clientUuid) {
1338     return Flux.empty();
1339   }
1340 
1341   @Override
1342   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsRealmCompositeGet(
1343       String realm, String clientUuid, Boolean briefRepresentation) {
1344     return Flux.empty();
1345   }
1346 
1347   @Override
1348   public Mono<Void> adminRealmsRealmClientsClientUuidScopeMappingsRealmDelete(String realm,
1349       String clientUuid, Flux<RoleRepresentation> roleRepresentation) {
1350     return Mono.empty();
1351   }
1352 
1353   @Override
1354   public Flux<RoleRepresentation> adminRealmsRealmClientsClientUuidScopeMappingsRealmGet(
1355       String realm, String clientUuid) {
1356     return Flux.empty();
1357   }
1358 
1359   @Override
1360   public Mono<Void> adminRealmsRealmClientsClientUuidScopeMappingsRealmPost(String realm,
1361       String clientUuid, Flux<RoleRepresentation> roleRepresentation) {
1362     return Mono.empty();
1363   }
1364 
1365   @Override
1366   public Mono<UserRepresentation> adminRealmsRealmClientsClientUuidServiceAccountUserGet(
1367       String realm, String clientUuid) {
1368     return Mono.empty();
1369   }
1370 
1371   @Override
1372   public Mono<Map<String, Long>> adminRealmsRealmClientsClientUuidSessionCountGet(String realm,
1373       String clientUuid) {
1374     return Mono.empty();
1375   }
1376 
1377   @Override
1378   public Mono<GlobalRequestResult> adminRealmsRealmClientsClientUuidTestNodesAvailableGet(
1379       String realm, String clientUuid) {
1380     return Mono.empty();
1381   }
1382 
1383   @Override
1384   public Flux<UserSessionRepresentation> adminRealmsRealmClientsClientUuidUserSessionsGet(
1385       String realm, String clientUuid, @Nullable Integer first,
1386       @Nullable Integer max) {
1387     return Flux.empty();
1388   }
1389 
1390   @Override
1391   public Flux<ClientRepresentation> adminRealmsRealmClientsGet(String realm,
1392       @Nullable String clientId, @Nullable Integer first,
1393       @Nullable Integer max, @Nullable String q, Boolean search,
1394       Boolean viewableOnly) {
1395     return Flux.empty();
1396   }
1397 
1398   @Override
1399   public Flux<ClientInitialAccessPresentation> adminRealmsRealmClientsInitialAccessGet(
1400       String realm) {
1401     return Flux.empty();
1402   }
1403 
1404   @Override
1405   public Mono<Void> adminRealmsRealmClientsInitialAccessIdDelete(String realm, String id) {
1406     return Mono.empty();
1407   }
1408 
1409   @Override
1410   public Mono<ClientInitialAccessCreatePresentation> adminRealmsRealmClientsInitialAccessPost(
1411       String realm,
1412       Mono<ClientInitialAccessCreatePresentation> clientInitialAccessCreatePresentation) {
1413     return Mono.empty();
1414   }
1415 
1416   @Override
1417   public Mono<Void> adminRealmsRealmClientsPost(String realm,
1418       Mono<ClientRepresentation> clientRepresentation) {
1419     return Mono.empty();
1420   }
1421 
1422   @Override
1423   public Flux<ComponentRepresentation> adminRealmsRealmComponentsGet(String realm,
1424       @Nullable String name, @Nullable String parent,
1425       @Nullable String providerId, @Nullable String type) {
1426     return Flux.empty();
1427   }
1428 
1429   @Override
1430   public Mono<Void> adminRealmsRealmComponentsIdDelete(String realm, String id) {
1431     return Mono.empty();
1432   }
1433 
1434   @Override
1435   public Mono<ComponentRepresentation> adminRealmsRealmComponentsIdGet(String realm, String id) {
1436     return Mono.empty();
1437   }
1438 
1439   @Override
1440   public Mono<Void> adminRealmsRealmComponentsIdPut(String realm, String id,
1441       Mono<ComponentRepresentation> componentRepresentation) {
1442     return Mono.empty();
1443   }
1444 
1445   @Override
1446   public Flux<ComponentTypeRepresentation> adminRealmsRealmComponentsIdSubComponentTypesGet(
1447       String realm, String id, @Nullable String type) {
1448     return Flux.empty();
1449   }
1450 
1451   @Override
1452   public Mono<Void> adminRealmsRealmComponentsPost(String realm,
1453       Mono<ComponentRepresentation> componentRepresentation) {
1454     return Mono.empty();
1455   }
1456 
1457   @Override
1458   public Mono<List<String>> adminRealmsRealmCredentialRegistratorsGet(String realm) {
1459     return Mono.empty();
1460   }
1461 
1462   @Override
1463   public Mono<Void> adminRealmsRealmDefaultDefaultClientScopesClientScopeIdDelete(String realm,
1464       String clientScopeId) {
1465     return Mono.empty();
1466   }
1467 
1468   @Override
1469   public Mono<Void> adminRealmsRealmDefaultDefaultClientScopesClientScopeIdPut(String realm,
1470       String clientScopeId) {
1471     return Mono.empty();
1472   }
1473 
1474   @Override
1475   public Flux<ClientScopeRepresentation> adminRealmsRealmDefaultDefaultClientScopesGet(
1476       String realm) {
1477     return Flux.empty();
1478   }
1479 
1480   @Override
1481   public Flux<GroupRepresentation> adminRealmsRealmDefaultGroupsGet(String realm) {
1482     return Flux.empty();
1483   }
1484 
1485   @Override
1486   public Mono<Void> adminRealmsRealmDefaultGroupsGroupIdDelete(String realm, String groupId) {
1487     return Mono.empty();
1488   }
1489 
1490   @Override
1491   public Mono<Void> adminRealmsRealmDefaultGroupsGroupIdPut(String realm, String groupId) {
1492     return Mono.empty();
1493   }
1494 
1495   @Override
1496   public Mono<Void> adminRealmsRealmDefaultOptionalClientScopesClientScopeIdDelete(String realm,
1497       String clientScopeId) {
1498     return Mono.empty();
1499   }
1500 
1501   @Override
1502   public Mono<Void> adminRealmsRealmDefaultOptionalClientScopesClientScopeIdPut(String realm,
1503       String clientScopeId) {
1504     return Mono.empty();
1505   }
1506 
1507   @Override
1508   public Flux<ClientScopeRepresentation> adminRealmsRealmDefaultOptionalClientScopesGet(
1509       String realm) {
1510     return Flux.empty();
1511   }
1512 
1513   @Override
1514   public Mono<Void> adminRealmsRealmDelete(String realm) {
1515     return Mono.empty();
1516   }
1517 
1518   @Override
1519   public Mono<RealmEventsConfigRepresentation> adminRealmsRealmEventsConfigGet(String realm) {
1520     return Mono.empty();
1521   }
1522 
1523   @Override
1524   public Mono<Void> adminRealmsRealmEventsConfigPut(String realm,
1525       Mono<RealmEventsConfigRepresentation> realmEventsConfigRepresentation) {
1526     return Mono.empty();
1527   }
1528 
1529   @Override
1530   public Mono<Void> adminRealmsRealmEventsDelete(String realm) {
1531     return Mono.empty();
1532   }
1533 
1534   @Override
1535   public Flux<EventRepresentation> adminRealmsRealmEventsGet(String realm,
1536       @Nullable String client, @Nullable String dateFrom,
1537       @Nullable String dateTo, @Nullable String direction,
1538       @Nullable Integer first, @Nullable String ipAddress,
1539       @Nullable Integer max, @Nullable List<String> type,
1540       @Nullable String user) {
1541     return Flux.empty();
1542   }
1543 
1544   @Override
1545   public Mono<RealmRepresentation> adminRealmsRealmGet(String realm) {
1546     return Mono.empty();
1547   }
1548 
1549   @Override
1550   public Mono<GroupRepresentation> adminRealmsRealmGroupByPathPathGet(String realm, String path) {
1551     return Mono.empty();
1552   }
1553 
1554   @Override
1555   public Mono<Map<String, Long>> adminRealmsRealmGroupsCountGet(String realm,
1556       @Nullable String search, Boolean top) {
1557     return Mono.empty();
1558   }
1559 
1560   @Override
1561   public Flux<GroupRepresentation> adminRealmsRealmGroupsGet(String realm,
1562       Boolean briefRepresentation, Boolean exact, @Nullable Integer first,
1563       @Nullable Integer max, Boolean populateHierarchy, @Nullable String q,
1564       @Nullable String search, Boolean subGroupsCount) {
1565     return Flux.empty();
1566   }
1567 
1568   @Override
1569   public Flux<GroupRepresentation> adminRealmsRealmGroupsGroupIdChildrenGet(String realm,
1570       String groupId, Boolean briefRepresentation, @Nullable Boolean exact,
1571       @Nullable Integer first, @Nullable Integer max, @Nullable String search,
1572       Boolean subGroupsCount) {
1573     return Flux.empty();
1574   }
1575 
1576   @Override
1577   public Mono<Void> adminRealmsRealmGroupsGroupIdChildrenPost(String realm, String groupId,
1578       Mono<GroupRepresentation> groupRepresentation) {
1579     return Mono.empty();
1580   }
1581 
1582   @Override
1583   public Mono<Void> adminRealmsRealmGroupsGroupIdDelete(String realm, String groupId) {
1584     return Mono.empty();
1585   }
1586 
1587   @Override
1588   public Mono<GroupRepresentation> adminRealmsRealmGroupsGroupIdGet(String realm, String groupId) {
1589     return Mono.empty();
1590   }
1591 
1592   @Override
1593   public Mono<ManagementPermissionReference> adminRealmsRealmGroupsGroupIdManagementPermissionsGet(
1594       String realm, String groupId) {
1595     return Mono.empty();
1596   }
1597 
1598   @Override
1599   public Mono<ManagementPermissionReference> adminRealmsRealmGroupsGroupIdManagementPermissionsPut(
1600       String realm, String groupId,
1601       Mono<ManagementPermissionReference> managementPermissionReference) {
1602     return Mono.empty();
1603   }
1604 
1605   @Override
1606   public Flux<UserRepresentation> adminRealmsRealmGroupsGroupIdMembersGet(String realm,
1607       String groupId, @Nullable Boolean briefRepresentation, @Nullable Integer first,
1608       @Nullable Integer max) {
1609     return Flux.empty();
1610   }
1611 
1612   @Override
1613   public Mono<Void> adminRealmsRealmGroupsGroupIdPut(String realm, String groupId,
1614       Mono<GroupRepresentation> groupRepresentation) {
1615     return Mono.empty();
1616   }
1617 
1618   @Override
1619   public Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdAvailableGet(
1620       String realm, String groupId, String clientId) {
1621     return Flux.empty();
1622   }
1623 
1624   @Override
1625   public Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdCompositeGet(
1626       String realm, String groupId, String clientId, Boolean briefRepresentation) {
1627     return Flux.empty();
1628   }
1629 
1630   @Override
1631   public Mono<Void> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdDelete(String realm,
1632       String groupId, String clientId, Flux<RoleRepresentation> roleRepresentation) {
1633     return Mono.empty();
1634   }
1635 
1636   @Override
1637   public Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdGet(
1638       String realm, String groupId, String clientId) {
1639     return Flux.empty();
1640   }
1641 
1642   @Override
1643   public Mono<Void> adminRealmsRealmGroupsGroupIdRoleMappingsClientsClientIdPost(String realm,
1644       String groupId, String clientId, Flux<RoleRepresentation> roleRepresentation) {
1645     return Mono.empty();
1646   }
1647 
1648   @Override
1649   public Mono<MappingsRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsGet(String realm,
1650       String groupId) {
1651     return Mono.empty();
1652   }
1653 
1654   @Override
1655   public Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsRealmAvailableGet(
1656       String realm, String groupId) {
1657     return Flux.empty();
1658   }
1659 
1660   @Override
1661   public Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsRealmCompositeGet(
1662       String realm, String groupId, Boolean briefRepresentation) {
1663     return Flux.empty();
1664   }
1665 
1666   @Override
1667   public Mono<Void> adminRealmsRealmGroupsGroupIdRoleMappingsRealmDelete(String realm,
1668       String groupId, Flux<RoleRepresentation> roleRepresentation) {
1669     return Mono.empty();
1670   }
1671 
1672   @Override
1673   public Flux<RoleRepresentation> adminRealmsRealmGroupsGroupIdRoleMappingsRealmGet(String realm,
1674       String groupId) {
1675     return Flux.empty();
1676   }
1677 
1678   @Override
1679   public Mono<Void> adminRealmsRealmGroupsGroupIdRoleMappingsRealmPost(String realm, String groupId,
1680       Flux<RoleRepresentation> roleRepresentation) {
1681     return Mono.empty();
1682   }
1683 
1684   @Override
1685   public Mono<Void> adminRealmsRealmGroupsPost(String realm,
1686       Mono<GroupRepresentation> groupRepresentation) {
1687     return Mono.empty();
1688   }
1689 
1690   @Override
1691   public Mono<Map<String, String>> adminRealmsRealmIdentityProviderImportConfigPost(String realm,
1692       Mono<Map<String, Object>> requestBody) {
1693     return Mono.empty();
1694   }
1695 
1696   @Override
1697   public Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasDelete(String realm,
1698       String alias) {
1699     return Mono.empty();
1700   }
1701 
1702   @Override
1703   public Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasExportGet(String realm,
1704       String alias, @Nullable String format) {
1705     return Mono.empty();
1706   }
1707 
1708   @Override
1709   public Mono<IdentityProviderRepresentation> adminRealmsRealmIdentityProviderInstancesAliasGet(
1710       String realm, String alias) {
1711     return Mono.empty();
1712   }
1713 
1714   @Override
1715   public Mono<ManagementPermissionReference> adminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsGet(
1716       String realm, String alias) {
1717     return Mono.empty();
1718   }
1719 
1720   @Override
1721   public Mono<ManagementPermissionReference> adminRealmsRealmIdentityProviderInstancesAliasManagementPermissionsPut(
1722       String realm, String alias,
1723       Mono<ManagementPermissionReference> managementPermissionReference) {
1724     return Mono.empty();
1725   }
1726 
1727   @Override
1728   public Mono<Map<String, IdentityProviderMapperTypeRepresentation>> adminRealmsRealmIdentityProviderInstancesAliasMapperTypesGet(
1729       String realm, String alias) {
1730     return Mono.empty();
1731   }
1732 
1733   @Override
1734   public Flux<IdentityProviderMapperRepresentation> adminRealmsRealmIdentityProviderInstancesAliasMappersGet(
1735       String realm, String alias) {
1736     return Flux.empty();
1737   }
1738 
1739   @Override
1740   public Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasMappersIdDelete(String realm,
1741       String alias, String id) {
1742     return Mono.empty();
1743   }
1744 
1745   @Override
1746   public Mono<IdentityProviderMapperRepresentation> adminRealmsRealmIdentityProviderInstancesAliasMappersIdGet(
1747       String realm, String alias, String id) {
1748     return Mono.empty();
1749   }
1750 
1751   @Override
1752   public Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasMappersIdPut(String realm,
1753       String alias, String id,
1754       Mono<IdentityProviderMapperRepresentation> identityProviderMapperRepresentation) {
1755     return Mono.empty();
1756   }
1757 
1758   @Override
1759   public Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasMappersPost(String realm,
1760       String alias,
1761       Mono<IdentityProviderMapperRepresentation> identityProviderMapperRepresentation) {
1762     return Mono.empty();
1763   }
1764 
1765   @Override
1766   public Mono<Void> adminRealmsRealmIdentityProviderInstancesAliasPut(String realm, String alias,
1767       Mono<IdentityProviderRepresentation> identityProviderRepresentation) {
1768     return Mono.empty();
1769   }
1770 
1771   @Override
1772   public Mono<Boolean> adminRealmsRealmIdentityProviderInstancesAliasReloadKeysGet(String realm,
1773       String alias) {
1774     return Mono.empty();
1775   }
1776 
1777   @Override
1778   public Flux<IdentityProviderRepresentation> adminRealmsRealmIdentityProviderInstancesGet(
1779       String realm, @Nullable Boolean briefRepresentation,
1780       @Nullable String capability, @Nullable Integer first,
1781       @Nullable Integer max, @Nullable Boolean realmOnly,
1782       @Nullable String search, @Nullable String type) {
1783     return Flux.empty();
1784   }
1785 
1786   @Override
1787   public Mono<Void> adminRealmsRealmIdentityProviderInstancesPost(String realm,
1788       Mono<IdentityProviderRepresentation> identityProviderRepresentation) {
1789     return Mono.empty();
1790   }
1791 
1792   @Override
1793   public Mono<Object> adminRealmsRealmIdentityProviderProvidersProviderIdGet(String realm,
1794       String providerId) {
1795     return Mono.empty();
1796   }
1797 
1798   @Override
1799   public Mono<CertificateRepresentation> adminRealmsRealmIdentityProviderUploadCertificatePost(
1800       String realm) {
1801     return Mono.empty();
1802   }
1803 
1804   @Override
1805   public Mono<KeysMetadataRepresentation> adminRealmsRealmKeysGet(String realm) {
1806     return Mono.empty();
1807   }
1808 
1809   @Override
1810   public Mono<List<String>> adminRealmsRealmLocalizationGet(String realm) {
1811     return Mono.empty();
1812   }
1813 
1814   @Override
1815   public Mono<Void> adminRealmsRealmLocalizationLocaleDelete(String realm, String locale) {
1816     return Mono.empty();
1817   }
1818 
1819   @Override
1820   public Mono<Map<String, String>> adminRealmsRealmLocalizationLocaleGet(String realm,
1821       String locale, @Nullable Boolean useRealmDefaultLocaleFallback) {
1822     return Mono.empty();
1823   }
1824 
1825   @Override
1826   public Mono<Void> adminRealmsRealmLocalizationLocaleKeyDelete(String realm, String key,
1827       String locale) {
1828     return Mono.empty();
1829   }
1830 
1831   @Override
1832   public Mono<String> adminRealmsRealmLocalizationLocaleKeyGet(String realm, String key,
1833       String locale) {
1834     return Mono.empty();
1835   }
1836 
1837   @Override
1838   public Mono<Void> adminRealmsRealmLocalizationLocaleKeyPut(String realm, String key,
1839       String locale, Mono<String> body) {
1840     return Mono.empty();
1841   }
1842 
1843   @Override
1844   public Mono<Void> adminRealmsRealmLocalizationLocalePost(String realm, String locale,
1845       Mono<Map<String, String>> requestBody) {
1846     return Mono.empty();
1847   }
1848 
1849   @Override
1850   public Mono<GlobalRequestResult> adminRealmsRealmLogoutAllPost(String realm) {
1851     return Mono.empty();
1852   }
1853 
1854   @Override
1855   public Mono<Long> adminRealmsRealmOrganizationsCountGet(String realm,
1856       @Nullable Boolean exact, @Nullable String q, @Nullable String search) {
1857     return Mono.empty();
1858   }
1859 
1860   @Override
1861   public Flux<OrganizationRepresentation> adminRealmsRealmOrganizationsGet(String realm,
1862       Boolean briefRepresentation, @Nullable Boolean exact,
1863       @Nullable Integer first, @Nullable Integer max, @Nullable String q,
1864       @Nullable String search) {
1865     return Flux.empty();
1866   }
1867 
1868   @Override
1869   public Flux<OrganizationRepresentation> adminRealmsRealmOrganizationsMembersMemberIdOrganizationsGet(
1870       String realm, String memberId, Boolean briefRepresentation) {
1871     return Flux.empty();
1872   }
1873 
1874   @Override
1875   public Mono<Void> adminRealmsRealmOrganizationsOrgIdDelete(String realm, String orgId) {
1876     return Mono.empty();
1877   }
1878 
1879   @Override
1880   public Mono<OrganizationRepresentation> adminRealmsRealmOrganizationsOrgIdGet(String realm,
1881       String orgId) {
1882     return Mono.empty();
1883   }
1884 
1885   @Override
1886   public Flux<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGet(String realm,
1887       String orgId, Boolean briefRepresentation, Boolean exact,
1888       @Nullable Integer first, @Nullable Integer max,
1889       Boolean populateHierarchy, @Nullable String q, @Nullable String search,
1890       Boolean subGroupsCount) {
1891     return Flux.empty();
1892   }
1893 
1894   @Override
1895   public Mono<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupByPathPathGet(
1896       String realm, String orgId, String path, Boolean subGroupsCount) {
1897     return Mono.empty();
1898   }
1899 
1900   @Override
1901   public Flux<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdChildrenGet(
1902       String realm, String orgId, String groupId, @Nullable Boolean exact,
1903       @Nullable Integer first, @Nullable Integer max, @Nullable String search,
1904       @Nullable Boolean subGroupsCount) {
1905     return Flux.empty();
1906   }
1907 
1908   @Override
1909   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdChildrenPost(String realm,
1910       String orgId, String groupId, Mono<GroupRepresentation> groupRepresentation) {
1911     return Mono.empty();
1912   }
1913 
1914   @Override
1915   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdDelete(String realm,
1916       String orgId, String groupId) {
1917     return Mono.empty();
1918   }
1919 
1920   @Override
1921   public Mono<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdGet(String realm,
1922       String orgId, String groupId, Boolean subGroupsCount) {
1923     return Mono.empty();
1924   }
1925 
1926   @Override
1927   public Flux<MemberRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersGet(
1928       String realm, String orgId, String groupId, @Nullable Boolean briefRepresentation,
1929       @Nullable Integer first, @Nullable Integer max) {
1930     return Flux.empty();
1931   }
1932 
1933   @Override
1934   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersUserIdDelete(String realm,
1935       String orgId, String groupId, String userId) {
1936     return Mono.empty();
1937   }
1938 
1939   @Override
1940   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdMembersUserIdPut(String realm,
1941       String orgId, String groupId, String userId) {
1942     return Mono.empty();
1943   }
1944 
1945   @Override
1946   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdPut(String realm, String orgId,
1947       String groupId, Mono<GroupRepresentation> groupRepresentation) {
1948     return Mono.empty();
1949   }
1950 
1951   @Override
1952   public Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdAvailableGet(
1953       String realm, String orgId, String groupId, String clientId) {
1954     return Flux.empty();
1955   }
1956 
1957   @Override
1958   public Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdCompositeGet(
1959       String realm, String orgId, String groupId, String clientId,
1960       Boolean briefRepresentation) {
1961     return Flux.empty();
1962   }
1963 
1964   @Override
1965   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdDelete(
1966       String realm, String orgId, String groupId, String clientId,
1967       Flux<RoleRepresentation> roleRepresentation) {
1968     return Mono.empty();
1969   }
1970 
1971   @Override
1972   public Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdGet(
1973       String realm, String orgId, String groupId, String clientId) {
1974     return Flux.empty();
1975   }
1976 
1977   @Override
1978   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsClientsClientIdPost(
1979       String realm, String orgId, String groupId, String clientId,
1980       Flux<RoleRepresentation> roleRepresentation) {
1981     return Mono.empty();
1982   }
1983 
1984   @Override
1985   public Mono<MappingsRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsGet(
1986       String realm, String orgId, String groupId) {
1987     return Mono.empty();
1988   }
1989 
1990   @Override
1991   public Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmAvailableGet(
1992       String realm, String orgId, String groupId) {
1993     return Flux.empty();
1994   }
1995 
1996   @Override
1997   public Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmCompositeGet(
1998       String realm, String orgId, String groupId, Boolean briefRepresentation) {
1999     return Flux.empty();
2000   }
2001 
2002   @Override
2003   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmDelete(
2004       String realm, String orgId, String groupId,
2005       Flux<RoleRepresentation> roleRepresentation) {
2006     return Mono.empty();
2007   }
2008 
2009   @Override
2010   public Flux<RoleRepresentation> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmGet(
2011       String realm, String orgId, String groupId) {
2012     return Flux.empty();
2013   }
2014 
2015   @Override
2016   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsGroupIdRoleMappingsRealmPost(
2017       String realm, String orgId, String groupId,
2018       Flux<RoleRepresentation> roleRepresentation) {
2019     return Mono.empty();
2020   }
2021 
2022   @Override
2023   public Mono<Void> adminRealmsRealmOrganizationsOrgIdGroupsPost(String realm, String orgId,
2024       Mono<GroupRepresentation> groupRepresentation) {
2025     return Mono.empty();
2026   }
2027 
2028   @Override
2029   public Mono<Void> adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasDelete(String realm,
2030       String orgId, String alias) {
2031     return Mono.empty();
2032   }
2033 
2034   @Override
2035   public Mono<IdentityProviderRepresentation> adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasGet(
2036       String realm, String orgId, String alias) {
2037     return Mono.empty();
2038   }
2039 
2040   @Override
2041   public Flux<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdIdentityProvidersAliasGroupsGet(
2042       String realm, String orgId, String alias, Boolean briefRepresentation,
2043       Boolean exact, @Nullable Integer first, @Nullable Integer max,
2044       @Nullable String q, @Nullable String search, Boolean subGroupsCount) {
2045     return Flux.empty();
2046   }
2047 
2048   @Override
2049   public Flux<IdentityProviderRepresentation> adminRealmsRealmOrganizationsOrgIdIdentityProvidersGet(
2050       String realm, String orgId) {
2051     return Flux.empty();
2052   }
2053 
2054   @Override
2055   public Mono<Void> adminRealmsRealmOrganizationsOrgIdIdentityProvidersPost(String realm,
2056       String orgId, Mono<String> body) {
2057     return Mono.empty();
2058   }
2059 
2060   @Override
2061   public Flux<OrganizationInvitationRepresentation> adminRealmsRealmOrganizationsOrgIdInvitationsGet(
2062       String realm, String orgId, @Nullable String email, @Nullable Integer first,
2063       @Nullable String firstName, @Nullable String lastName,
2064       @Nullable Integer max, @Nullable String search,
2065       @Nullable String status) {
2066     return Flux.empty();
2067   }
2068 
2069   @Override
2070   public Mono<Void> adminRealmsRealmOrganizationsOrgIdInvitationsIdDelete(String realm,
2071       String orgId, String id) {
2072     return Mono.empty();
2073   }
2074 
2075   @Override
2076   public Mono<OrganizationInvitationRepresentation> adminRealmsRealmOrganizationsOrgIdInvitationsIdGet(
2077       String realm, String orgId, String id) {
2078     return Mono.empty();
2079   }
2080 
2081   @Override
2082   public Mono<Void> adminRealmsRealmOrganizationsOrgIdInvitationsIdResendPost(String realm,
2083       String orgId, String id) {
2084     return Mono.empty();
2085   }
2086 
2087   @Override
2088   public Mono<Long> adminRealmsRealmOrganizationsOrgIdMembersCountGet(String realm, String orgId) {
2089     return Mono.empty();
2090   }
2091 
2092   @Override
2093   public Flux<MemberRepresentation> adminRealmsRealmOrganizationsOrgIdMembersGet(String realm,
2094       String orgId, Boolean briefRepresentation, @Nullable Boolean exact,
2095       @Nullable Integer first, @Nullable Integer max,
2096       @Nullable String membershipType, @Nullable String search) {
2097     return Flux.empty();
2098   }
2099 
2100   @Override
2101   public Mono<Void> adminRealmsRealmOrganizationsOrgIdMembersInviteExistingUserPost(String realm,
2102       String orgId, String id) {
2103     return Mono.empty();
2104   }
2105 
2106   @Override
2107   public Mono<Void> adminRealmsRealmOrganizationsOrgIdMembersInviteUserPost(String realm,
2108       String orgId, String email, String firstName, String lastName) {
2109     return Mono.empty();
2110   }
2111 
2112   @Override
2113   public Mono<Void> adminRealmsRealmOrganizationsOrgIdMembersMemberIdDelete(String realm,
2114       String orgId, String memberId) {
2115     return Mono.empty();
2116   }
2117 
2118   @Override
2119   public Mono<MemberRepresentation> adminRealmsRealmOrganizationsOrgIdMembersMemberIdGet(
2120       String realm, String orgId, String memberId) {
2121     return Mono.empty();
2122   }
2123 
2124   @Override
2125   public Flux<GroupRepresentation> adminRealmsRealmOrganizationsOrgIdMembersMemberIdGroupsGet(
2126       String realm, String orgId, String memberId, Boolean briefRepresentation,
2127       @Nullable Integer first, @Nullable Integer max,
2128       @Nullable String search) {
2129     return Flux.empty();
2130   }
2131 
2132   @Override
2133   public Flux<OrganizationRepresentation> adminRealmsRealmOrganizationsOrgIdMembersMemberIdOrganizationsGet(
2134       String realm, String orgId, String memberId, Boolean briefRepresentation) {
2135     return Flux.empty();
2136   }
2137 
2138   @Override
2139   public Mono<Void> adminRealmsRealmOrganizationsOrgIdMembersPost(String realm, String orgId,
2140       Mono<String> body) {
2141     return Mono.empty();
2142   }
2143 
2144   @Override
2145   public Mono<Void> adminRealmsRealmOrganizationsOrgIdPut(String realm, String orgId,
2146       Mono<OrganizationRepresentation> organizationRepresentation) {
2147     return Mono.empty();
2148   }
2149 
2150   @Override
2151   public Mono<Void> adminRealmsRealmOrganizationsPost(String realm,
2152       Mono<OrganizationRepresentation> organizationRepresentation) {
2153     return Mono.empty();
2154   }
2155 
2156   @Override
2157   public Mono<RealmRepresentation> adminRealmsRealmPartialExportPost(String realm,
2158       @Nullable Boolean exportClients, @Nullable Boolean exportGroupsAndRoles) {
2159     return Mono.empty();
2160   }
2161 
2162   @Override
2163   public Mono<Object> adminRealmsRealmPartialImportPost(String realm, Mono<Resource> body) {
2164     return Mono.empty();
2165   }
2166 
2167   @Override
2168   public Mono<GlobalRequestResult> adminRealmsRealmPushRevocationPost(String realm) {
2169     return Mono.empty();
2170   }
2171 
2172   @Override
2173   public Mono<Void> adminRealmsRealmPut(String realm,
2174       Mono<RealmRepresentation> realmRepresentation) {
2175     return Mono.empty();
2176   }
2177 
2178   @Override
2179   public Flux<RoleRepresentation> adminRealmsRealmRolesByIdRoleIdCompositesClientsClientUuidGet(
2180       String realm, String clientUuid, String roleId) {
2181     return Flux.empty();
2182   }
2183 
2184   @Override
2185   public Mono<Void> adminRealmsRealmRolesByIdRoleIdCompositesDelete(String realm, String roleId,
2186       Flux<RoleRepresentation> roleRepresentation) {
2187     return Mono.empty();
2188   }
2189 
2190   @Override
2191   public Flux<RoleRepresentation> adminRealmsRealmRolesByIdRoleIdCompositesGet(String realm,
2192       String roleId, @Nullable Integer first, @Nullable Integer max,
2193       @Nullable String search) {
2194     return Flux.empty();
2195   }
2196 
2197   @Override
2198   public Mono<Void> adminRealmsRealmRolesByIdRoleIdCompositesPost(String realm, String roleId,
2199       Flux<RoleRepresentation> roleRepresentation) {
2200     return Mono.empty();
2201   }
2202 
2203   @Override
2204   public Flux<RoleRepresentation> adminRealmsRealmRolesByIdRoleIdCompositesRealmGet(String realm,
2205       String roleId) {
2206     return Flux.empty();
2207   }
2208 
2209   @Override
2210   public Mono<Void> adminRealmsRealmRolesByIdRoleIdDelete(String realm, String roleId) {
2211     return Mono.empty();
2212   }
2213 
2214   @Override
2215   public Mono<RoleRepresentation> adminRealmsRealmRolesByIdRoleIdGet(String realm, String roleId) {
2216     return Mono.empty();
2217   }
2218 
2219   @Override
2220   public Mono<ManagementPermissionReference> adminRealmsRealmRolesByIdRoleIdManagementPermissionsGet(
2221       String realm, String roleId) {
2222     return Mono.empty();
2223   }
2224 
2225   @Override
2226   public Mono<ManagementPermissionReference> adminRealmsRealmRolesByIdRoleIdManagementPermissionsPut(
2227       String realm, String roleId,
2228       Mono<ManagementPermissionReference> managementPermissionReference) {
2229     return Mono.empty();
2230   }
2231 
2232   @Override
2233   public Mono<Void> adminRealmsRealmRolesByIdRoleIdPut(String realm, String roleId,
2234       Mono<RoleRepresentation> roleRepresentation) {
2235     return Mono.empty();
2236   }
2237 
2238   @Override
2239   public Flux<RoleRepresentation> adminRealmsRealmRolesGet(String realm,
2240       Boolean briefRepresentation, @Nullable Integer first,
2241       @Nullable Integer max, String search) {
2242     return Flux.empty();
2243   }
2244 
2245   @Override
2246   public Mono<Void> adminRealmsRealmRolesPost(String realm,
2247       Mono<RoleRepresentation> roleRepresentation) {
2248     return Mono.empty();
2249   }
2250 
2251   @Override
2252   public Flux<RoleRepresentation> adminRealmsRealmRolesRoleNameCompositesClientsTargetClientUuidGet(
2253       String realm, String roleName, String targetClientUuid) {
2254     return Flux.empty();
2255   }
2256 
2257   @Override
2258   public Mono<Void> adminRealmsRealmRolesRoleNameCompositesDelete(String realm, String roleName,
2259       Flux<RoleRepresentation> roleRepresentation) {
2260     return Mono.empty();
2261   }
2262 
2263   @Override
2264   public Flux<RoleRepresentation> adminRealmsRealmRolesRoleNameCompositesGet(String realm,
2265       String roleName) {
2266     return Flux.empty();
2267   }
2268 
2269   @Override
2270   public Mono<Void> adminRealmsRealmRolesRoleNameCompositesPost(String realm, String roleName,
2271       Flux<RoleRepresentation> roleRepresentation) {
2272     return Mono.empty();
2273   }
2274 
2275   @Override
2276   public Flux<RoleRepresentation> adminRealmsRealmRolesRoleNameCompositesRealmGet(String realm,
2277       String roleName) {
2278     return Flux.empty();
2279   }
2280 
2281   @Override
2282   public Mono<Void> adminRealmsRealmRolesRoleNameDelete(String realm, String roleName) {
2283     return Mono.empty();
2284   }
2285 
2286   @Override
2287   public Mono<RoleRepresentation> adminRealmsRealmRolesRoleNameGet(String realm, String roleName) {
2288     return Mono.empty();
2289   }
2290 
2291   @Override
2292   public Flux<UserRepresentation> adminRealmsRealmRolesRoleNameGroupsGet(String realm,
2293       String roleName, @Nullable Integer max, Boolean briefRepresentation,
2294       @Nullable Integer first) {
2295     return Flux.empty();
2296   }
2297 
2298   @Override
2299   public Mono<ManagementPermissionReference> adminRealmsRealmRolesRoleNameManagementPermissionsGet(
2300       String realm, String roleName) {
2301     return Mono.empty();
2302   }
2303 
2304   @Override
2305   public Mono<ManagementPermissionReference> adminRealmsRealmRolesRoleNameManagementPermissionsPut(
2306       String realm, String roleName,
2307       Mono<ManagementPermissionReference> managementPermissionReference) {
2308     return Mono.empty();
2309   }
2310 
2311   @Override
2312   public Mono<Void> adminRealmsRealmRolesRoleNamePut(String realm, String roleName,
2313       Mono<RoleRepresentation> roleRepresentation) {
2314     return Mono.empty();
2315   }
2316 
2317   @Override
2318   public Flux<UserRepresentation> adminRealmsRealmRolesRoleNameUsersGet(String realm,
2319       String roleName, @Nullable Boolean briefRepresentation, @Nullable Integer first,
2320       @Nullable Integer max) {
2321     return Flux.empty();
2322   }
2323 
2324   @Override
2325   public Mono<Void> adminRealmsRealmSessionsSessionDelete(String realm, String session,
2326       Boolean isOffline) {
2327     return Mono.empty();
2328   }
2329 
2330   @Override
2331   public Mono<Integer> adminRealmsRealmUsersCountGet(String realm,
2332       @Nullable String createdAfter, @Nullable String createdBefore,
2333       @Nullable String email, @Nullable Boolean emailVerified,
2334       @Nullable Boolean enabled, @Nullable Boolean exact,
2335       @Nullable String firstName, @Nullable String idpAlias,
2336       @Nullable String idpUserId, @Nullable String lastName,
2337       @Nullable String q, @Nullable String search, @Nullable String username) {
2338     return Mono.empty();
2339   }
2340 
2341   @Override
2342   public Flux<UserRepresentation> adminRealmsRealmUsersGet(String realm,
2343       @Nullable Boolean briefRepresentation, @Nullable String createdAfter,
2344       @Nullable String createdBefore, @Nullable String email,
2345       @Nullable Boolean emailVerified, @Nullable Boolean enabled,
2346       @Nullable Boolean exact, @Nullable Integer first,
2347       @Nullable String firstName, @Nullable String idpAlias,
2348       @Nullable String idpUserId, @Nullable String lastName,
2349       @Nullable Integer max, @Nullable String q, @Nullable String search,
2350       @Nullable String username) {
2351     return Flux.empty();
2352   }
2353 
2354   @Override
2355   public Mono<ManagementPermissionReference> adminRealmsRealmUsersManagementPermissionsGet(
2356       String realm) {
2357     return Mono.empty();
2358   }
2359 
2360   @Override
2361   public Mono<ManagementPermissionReference> adminRealmsRealmUsersManagementPermissionsPut(
2362       String realm, Mono<ManagementPermissionReference> managementPermissionReference) {
2363     return Mono.empty();
2364   }
2365 
2366   @Override
2367   public Mono<Void> adminRealmsRealmUsersPost(String realm,
2368       Mono<UserRepresentation> userRepresentation) {
2369     return Mono.empty();
2370   }
2371 
2372   @Override
2373   public Mono<UPConfig> adminRealmsRealmUsersProfileGet(String realm) {
2374     return Mono.empty();
2375   }
2376 
2377   @Override
2378   public Mono<UserProfileMetadata> adminRealmsRealmUsersProfileMetadataGet(String realm) {
2379     return Mono.empty();
2380   }
2381 
2382   @Override
2383   public Mono<UPConfig> adminRealmsRealmUsersProfilePut(String realm,
2384       Mono<UPConfig> upConfig) {
2385     return Mono.empty();
2386   }
2387 
2388   @Override
2389   public Mono<List<String>> adminRealmsRealmUsersUserIdConfiguredUserStorageCredentialTypesGet(
2390       String realm, String userId) {
2391     return Mono.empty();
2392   }
2393 
2394   @Override
2395   public Mono<Void> adminRealmsRealmUsersUserIdConsentsClientDelete(String realm, String userId,
2396       String client) {
2397     return Mono.empty();
2398   }
2399 
2400   @Override
2401   public Flux<Map<String, Object>> adminRealmsRealmUsersUserIdConsentsGet(String realm,
2402       String userId) {
2403     return Flux.empty();
2404   }
2405 
2406   @Override
2407   public Mono<Void> adminRealmsRealmUsersUserIdCredentialsCredentialIdDelete(String realm,
2408       String userId, String credentialId) {
2409     return Mono.empty();
2410   }
2411 
2412   @Override
2413   public Mono<Void> adminRealmsRealmUsersUserIdCredentialsCredentialIdMoveAfterNewPreviousCredentialIdPost(
2414       String realm, String userId, String credentialId, String newPreviousCredentialId) {
2415     return Mono.empty();
2416   }
2417 
2418   @Override
2419   public Mono<Void> adminRealmsRealmUsersUserIdCredentialsCredentialIdMoveToFirstPost(String realm,
2420       String userId, String credentialId) {
2421     return Mono.empty();
2422   }
2423 
2424   @Override
2425   public Mono<Void> adminRealmsRealmUsersUserIdCredentialsCredentialIdUserLabelPut(String realm,
2426       String userId, String credentialId, Mono<String> body) {
2427     return Mono.empty();
2428   }
2429 
2430   @Override
2431   public Flux<CredentialRepresentation> adminRealmsRealmUsersUserIdCredentialsGet(String realm,
2432       String userId) {
2433     return Flux.empty();
2434   }
2435 
2436   @Override
2437   public Mono<Void> adminRealmsRealmUsersUserIdDelete(String realm, String userId) {
2438     return Mono.empty();
2439   }
2440 
2441   @Override
2442   public Mono<Void> adminRealmsRealmUsersUserIdDisableCredentialTypesPut(String realm,
2443       String userId, Flux<String> requestBody) {
2444     return Mono.empty();
2445   }
2446 
2447   @Override
2448   public Mono<Void> adminRealmsRealmUsersUserIdExecuteActionsEmailPut(String realm, String userId,
2449       @Nullable String clientId, @Nullable Integer lifespan,
2450       @Nullable String redirectUri, Flux<String> requestBody) {
2451     return Mono.empty();
2452   }
2453 
2454   @Override
2455   public Flux<FederatedIdentityRepresentation> adminRealmsRealmUsersUserIdFederatedIdentityGet(
2456       String realm, String userId) {
2457     return Flux.empty();
2458   }
2459 
2460   @Override
2461   public Mono<Void> adminRealmsRealmUsersUserIdFederatedIdentityProviderDelete(String realm,
2462       String userId, String provider) {
2463     return Mono.empty();
2464   }
2465 
2466   @Override
2467   public Mono<Void> adminRealmsRealmUsersUserIdFederatedIdentityProviderPost(String realm,
2468       String userId, String provider,
2469       Mono<FederatedIdentityRepresentation> federatedIdentityRepresentation) {
2470     return Mono.empty();
2471   }
2472 
2473   @Override
2474   public Mono<UserRepresentation> adminRealmsRealmUsersUserIdGet(String realm, String userId,
2475       @Nullable Boolean userProfileMetadata) {
2476     return Mono.empty();
2477   }
2478 
2479   @Override
2480   public Mono<Map<String, Long>> adminRealmsRealmUsersUserIdGroupsCountGet(String realm,
2481       String userId, @Nullable String search) {
2482     return Mono.empty();
2483   }
2484 
2485   @Override
2486   public Flux<GroupRepresentation> adminRealmsRealmUsersUserIdGroupsGet(String realm, String userId,
2487       Boolean briefRepresentation, @Nullable Integer first,
2488       @Nullable Integer max, @Nullable String search) {
2489     return Flux.empty();
2490   }
2491 
2492   @Override
2493   public Mono<Void> adminRealmsRealmUsersUserIdGroupsGroupIdDelete(String realm, String userId,
2494       String groupId) {
2495     return Mono.empty();
2496   }
2497 
2498   @Override
2499   public Mono<Void> adminRealmsRealmUsersUserIdGroupsGroupIdPut(String realm, String userId,
2500       String groupId) {
2501     return Mono.empty();
2502   }
2503 
2504   @Override
2505   public Mono<Map<String, Object>> adminRealmsRealmUsersUserIdImpersonationPost(String realm,
2506       String userId) {
2507     return Mono.empty();
2508   }
2509 
2510   @Override
2511   public Mono<Void> adminRealmsRealmUsersUserIdLogoutPost(String realm, String userId) {
2512     return Mono.empty();
2513   }
2514 
2515   @Override
2516   public Flux<UserSessionRepresentation> adminRealmsRealmUsersUserIdOfflineSessionsClientUuidGet(
2517       String realm, String userId, String clientUuid) {
2518     return Flux.empty();
2519   }
2520 
2521   @Override
2522   public Mono<Void> adminRealmsRealmUsersUserIdPut(String realm, String userId,
2523       Mono<UserRepresentation> userRepresentation) {
2524     return Mono.empty();
2525   }
2526 
2527   @Override
2528   public Mono<Void> adminRealmsRealmUsersUserIdResetPasswordEmailPut(String realm, String userId,
2529       @Nullable String clientId, @Nullable String redirectUri) {
2530     return Mono.empty();
2531   }
2532 
2533   @Override
2534   public Mono<Void> adminRealmsRealmUsersUserIdResetPasswordPut(String realm, String userId,
2535       Mono<CredentialRepresentation> credentialRepresentation) {
2536     return Mono.empty();
2537   }
2538 
2539   @Override
2540   public Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdAvailableGet(
2541       String realm, String userId, String clientId) {
2542     return Flux.empty();
2543   }
2544 
2545   @Override
2546   public Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdCompositeGet(
2547       String realm, String userId, String clientId, Boolean briefRepresentation) {
2548     return Flux.empty();
2549   }
2550 
2551   @Override
2552   public Mono<Void> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdDelete(String realm,
2553       String userId, String clientId, Flux<RoleRepresentation> roleRepresentation) {
2554     return Mono.empty();
2555   }
2556 
2557   @Override
2558   public Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdGet(
2559       String realm, String userId, String clientId) {
2560     return Flux.empty();
2561   }
2562 
2563   @Override
2564   public Mono<Void> adminRealmsRealmUsersUserIdRoleMappingsClientsClientIdPost(String realm,
2565       String userId, String clientId, Flux<RoleRepresentation> roleRepresentation) {
2566     return Mono.empty();
2567   }
2568 
2569   @Override
2570   public Mono<MappingsRepresentation> adminRealmsRealmUsersUserIdRoleMappingsGet(String realm,
2571       String userId) {
2572     return Mono.empty();
2573   }
2574 
2575   @Override
2576   public Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsRealmAvailableGet(
2577       String realm, String userId) {
2578     return Flux.empty();
2579   }
2580 
2581   @Override
2582   public Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsRealmCompositeGet(
2583       String realm, String userId, Boolean briefRepresentation) {
2584     return Flux.empty();
2585   }
2586 
2587   @Override
2588   public Mono<Void> adminRealmsRealmUsersUserIdRoleMappingsRealmDelete(String realm, String userId,
2589       Flux<RoleRepresentation> roleRepresentation) {
2590     return Mono.empty();
2591   }
2592 
2593   @Override
2594   public Flux<RoleRepresentation> adminRealmsRealmUsersUserIdRoleMappingsRealmGet(String realm,
2595       String userId) {
2596     return Flux.empty();
2597   }
2598 
2599   @Override
2600   public Mono<Void> adminRealmsRealmUsersUserIdRoleMappingsRealmPost(String realm, String userId,
2601       Flux<RoleRepresentation> roleRepresentation) {
2602     return Mono.empty();
2603   }
2604 
2605   @Override
2606   public Mono<Void> adminRealmsRealmUsersUserIdSendVerifyEmailPut(String realm, String userId,
2607       @Nullable String clientId, @Nullable Integer lifespan,
2608       @Nullable String redirectUri) {
2609     return Mono.empty();
2610   }
2611 
2612   @Override
2613   public Flux<UserSessionRepresentation> adminRealmsRealmUsersUserIdSessionsGet(String realm,
2614       String userId) {
2615     return Flux.empty();
2616   }
2617 
2618   @Override
2619   public Mono<Map<String, List<String>>> adminRealmsRealmUsersUserIdUnmanagedAttributesGet(
2620       String realm, String userId) {
2621     return Mono.empty();
2622   }
2623 
2624   @Override
2625   public Mono<WorkflowRepresentation> adminRealmsRealmWorkflowsGet(String realm,
2626       @Nullable Boolean exact, @Nullable Integer first, @Nullable Integer max,
2627       @Nullable String search) {
2628     return Mono.empty();
2629   }
2630 
2631   @Override
2632   public Mono<Void> adminRealmsRealmWorkflowsIdActivateTypeResourceIdPost(String realm, String id,
2633       String resourceId, Object type, @Nullable String notBefore) {
2634     return Mono.empty();
2635   }
2636 
2637   @Override
2638   public Mono<Void> adminRealmsRealmWorkflowsIdDeactivateTypeResourceIdPost(String realm, String id,
2639       String resourceId, Object type) {
2640     return Mono.empty();
2641   }
2642 
2643   @Override
2644   public Mono<Void> adminRealmsRealmWorkflowsIdDelete(String realm, String id) {
2645     return Mono.empty();
2646   }
2647 
2648   @Override
2649   public Mono<WorkflowRepresentation> adminRealmsRealmWorkflowsIdGet(String realm, String id,
2650       @Nullable Boolean includeId) {
2651     return Mono.empty();
2652   }
2653 
2654   @Override
2655   public Mono<Void> adminRealmsRealmWorkflowsIdPut(String realm, String id,
2656       Mono<WorkflowRepresentation> workflowRepresentation) {
2657     return Mono.empty();
2658   }
2659 
2660   @Override
2661   public Mono<Void> adminRealmsRealmWorkflowsMigratePost(String realm, @Nullable String from,
2662       @Nullable String to) {
2663     return Mono.empty();
2664   }
2665 
2666   @Override
2667   public Mono<Void> adminRealmsRealmWorkflowsPost(String realm,
2668       Mono<WorkflowRepresentation> workflowRepresentation) {
2669     return Mono.empty();
2670   }
2671 
2672   @Override
2673   public Mono<WorkflowRepresentation> adminRealmsRealmWorkflowsScheduledResourceIdGet(String realm,
2674       String resourceId) {
2675     return Mono.empty();
2676   }
2677 }