Performs the logistics of collecting and assembling the individual health check information
on a per-service basis.

@return an observable with the response once ready.
764141
public Observable<DiagnosticsResponse> diagnostics(final String id) {
        List<Observable<EndpointHealth>> diags = new ArrayList<Observable<EndpointHealth>>(nodes.size());
        for (Node node : nodes) {
            diags.add(node.diagnostics());
        }
        final RingBufferDiagnostics ringBufferDiagnostics = RingBufferMonitor.instance().diagnostics();
        return Observable.merge(diags).toList().map(new Func1<List<EndpointHealth>, DiagnosticsResponse>() {
            @Override
            public DiagnosticsResponse call(List<EndpointHealth> checks) {
                return new DiagnosticsResponse(new DiagnosticsReport(checks, environment.userAgent(), id, ringBufferDiagnostics));
            }
        });
    }
180099
public Observable<Page<VirtualNetworkInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<VirtualNetworkInner>>, Page<VirtualNetworkInner>>() {
                @Override
                public Page<VirtualNetworkInner> call(ServiceResponse<Page<VirtualNetworkInner>> response) {
                    return response.body();
                }
            });
    }
43729
public Observable<Page<FeatureResultInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<FeatureResultInner>>, Page<FeatureResultInner>>() {
                @Override
                public Page<FeatureResultInner> call(ServiceResponse<Page<FeatureResultInner>> response) {
                    return response.body();
                }
            });
    }
265276
public Observable<Page<RouteFilterInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<RouteFilterInner>>, Page<RouteFilterInner>>() {
                @Override
                public Page<RouteFilterInner> call(ServiceResponse<Page<RouteFilterInner>> response) {
                    return response.body();
                }
            });
    }
368167
Observable<ChatResult> synchroniseStore() {
        if (isSynchronising.getAndSet(true)) {
            log.i("Synchronisation in progress.");
            return Observable.fromCallable(() -> new ChatResult(true, null));
        }
        log.i("Synchronising store.");
        return synchroniseConversations()
                .onErrorReturn(t -> new ChatResult(false, new ChatResult.Error(0, t)))
                .doOnNext(i -> {
                    if (i.isSuccessful()) {
                        log.i("Synchronisation successfully finished.");
                    } else {
                        log.e("Synchronisation finished with error. " + (i.getError() != null ? i.getError().getDetails() : ""));
                    }
                    isSynchronising.compareAndSet(true, false);
                });
    }
1112387
public Observable<Page<CertificateInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<CertificateInner>>, Page<CertificateInner>>() {
                @Override
                public Page<CertificateInner> call(ServiceResponse<Page<CertificateInner>> response) {
                    return response.body();
                }
            });
    }
1292266
public Observable<Page<PublicIPPrefixInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<PublicIPPrefixInner>>, Page<PublicIPPrefixInner>>() {
                @Override
                public Page<PublicIPPrefixInner> call(ServiceResponse<Page<PublicIPPrefixInner>> response) {
                    return response.body();
                }
            });
    }
1117999
public Observable<List<Project>> getProjectsAsync() {
        return getProjectsWithServiceResponseAsync().map(new Func1<ServiceResponse<List<Project>>, List<Project>>() {
            @Override
            public List<Project> call(ServiceResponse<List<Project>> response) {
                return response.body();
            }
        });
    }
1182636
public Observable<Page<OperationEntityInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<OperationEntityInner>>, Page<OperationEntityInner>>() {
                @Override
                public Page<OperationEntityInner> call(ServiceResponse<Page<OperationEntityInner>> response) {
                    return response.body();
                }
            });
    }
98104
public Observable<ServiceResponse<UserInner>> getPublishingUserWithServiceResponseAsync() {
        if (this.apiVersion() == null) {
            throw new IllegalArgumentException("Parameter this.apiVersion() is required and cannot be null.");
        }
        return service.getPublishingUser(this.apiVersion(), this.acceptLanguage(), this.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<UserInner>>>() {
                @Override
                public Observable<ServiceResponse<UserInner>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<UserInner> clientResponse = getPublishingUserDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
540808
public Observable<Page<P2SVpnGatewayInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<P2SVpnGatewayInner>>, Page<P2SVpnGatewayInner>>() {
                @Override
                public Page<P2SVpnGatewayInner> call(ServiceResponse<Page<P2SVpnGatewayInner>> response) {
                    return response.body();
                }
            });
    }
343695
public Observable<Page<ProviderInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<ProviderInner>>, Page<ProviderInner>>() {
                @Override
                public Page<ProviderInner> call(ServiceResponse<Page<ProviderInner>> response) {
                    return response.body();
                }
            });
    }
585459
public Observable<Page<InterfaceEndpointInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<InterfaceEndpointInner>>, Page<InterfaceEndpointInner>>() {
                @Override
                public Page<InterfaceEndpointInner> call(ServiceResponse<Page<InterfaceEndpointInner>> response) {
                    return response.body();
                }
            });
    }
485336
public Observable<List<OperationValueInner>> listAsync() {
        return listWithServiceResponseAsync().map(new Func1<ServiceResponse<List<OperationValueInner>>, List<OperationValueInner>>() {
            @Override
            public List<OperationValueInner> call(ServiceResponse<List<OperationValueInner>> response) {
                return response.body();
            }
        });
    }
13982
public Observable<Page<JobInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<JobInner>>, Page<JobInner>>() {
                @Override
                public Page<JobInner> call(ServiceResponse<Page<JobInner>> response) {
                    return response.body();
                }
            });
    }
910472
public Observable<ServiceResponse<Project>> getProjectWithServiceResponseAsync(UUID projectId) {
        if (projectId == null) {
            throw new IllegalArgumentException("Parameter projectId is required and cannot be null.");
        }
        if (this.client.apiKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiKey() is required and cannot be null.");
        }
        return service.getProject(projectId, this.client.apiKey(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Project>>>() {
                @Override
                public Observable<ServiceResponse<Project>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Project> clientResponse = getProjectDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
266614
public Observable<AVUser> signUpInBackground() {
    JSONObject paramData = generateChangedParam();
    logger.d("signup param: " + paramData.toJSONString());
    return PaasClient.getStorageClient().signUp(paramData).map(new Function<AVUser, AVUser>() {
      @Override
      public AVUser apply(AVUser avUser) throws Exception {
        AVUser.this.mergeRawData(avUser);
        return AVUser.this;
      }
    });
  }