fixtures.url.implementation.QueriesImpl.java Source code

Introduction

Here is the source code for fixtures.url.implementation.QueriesImpl.java

Source

/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for
 * license information.
 *
 * Code generated by Microsoft (R) AutoRest Code Generator.
 * Changes may cause incorrect behavior and will be lost if the code is
 * regenerated.
 */

package fixtures.url.implementation;

import retrofit2.Retrofit;
import fixtures.url.Queries;
import com.google.common.reflect.TypeToken;
import com.microsoft.rest.serializer.CollectionFormat;
import com.microsoft.rest.ServiceCall;
import com.microsoft.rest.ServiceCallback;
import com.microsoft.rest.ServiceResponse;
import com.microsoft.rest.ServiceResponseBuilder;
import com.microsoft.rest.Validator;
import fixtures.url.models.ErrorException;
import fixtures.url.models.UriColor;
import java.io.IOException;
import java.util.List;
import okhttp3.ResponseBody;
import org.apache.commons.codec.binary.Base64;
import org.joda.time.DateTime;
import org.joda.time.LocalDate;
import retrofit2.http.GET;
import retrofit2.http.Headers;
import retrofit2.http.Query;
import retrofit2.Response;
import rx.functions.Func1;
import rx.Observable;

/**
 * An instance of this class provides access to all the operations defined
 * in Queries.
 */
public final class QueriesImpl implements Queries {
    /** The Retrofit service to perform REST calls. */
    private QueriesService service;
    /** The service client containing this operation class. */
    private AutoRestUrlTestServiceImpl client;

    /**
     * Initializes an instance of Queries.
     *
     * @param retrofit the Retrofit instance built from a Retrofit Builder.
     * @param client the instance of the service client containing this operation class.
     */
    public QueriesImpl(Retrofit retrofit, AutoRestUrlTestServiceImpl client) {
        this.service = retrofit.create(QueriesService.class);
        this.client = client;
    }

    /**
     * The interface defining all the services for Queries to be
     * used by Retrofit to perform actually REST calls.
     */
    interface QueriesService {
        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/bool/true")
        Observable<Response<ResponseBody>> getBooleanTrue(@Query("boolQuery") boolean boolQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/bool/false")
        Observable<Response<ResponseBody>> getBooleanFalse(@Query("boolQuery") boolean boolQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/bool/null")
        Observable<Response<ResponseBody>> getBooleanNull(@Query("boolQuery") Boolean boolQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/int/1000000")
        Observable<Response<ResponseBody>> getIntOneMillion(@Query("intQuery") int intQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/int/-1000000")
        Observable<Response<ResponseBody>> getIntNegativeOneMillion(@Query("intQuery") int intQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/int/null")
        Observable<Response<ResponseBody>> getIntNull(@Query("intQuery") Integer intQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/long/10000000000")
        Observable<Response<ResponseBody>> getTenBillion(@Query("longQuery") long longQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/long/-10000000000")
        Observable<Response<ResponseBody>> getNegativeTenBillion(@Query("longQuery") long longQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/long/null")
        Observable<Response<ResponseBody>> getLongNull(@Query("longQuery") Long longQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/float/1.034E+20")
        Observable<Response<ResponseBody>> floatScientificPositive(@Query("floatQuery") double floatQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/float/-1.034E-20")
        Observable<Response<ResponseBody>> floatScientificNegative(@Query("floatQuery") double floatQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/float/null")
        Observable<Response<ResponseBody>> floatNull(@Query("floatQuery") Double floatQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/double/9999999.999")
        Observable<Response<ResponseBody>> doubleDecimalPositive(@Query("doubleQuery") double doubleQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/double/-9999999.999")
        Observable<Response<ResponseBody>> doubleDecimalNegative(@Query("doubleQuery") double doubleQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/double/null")
        Observable<Response<ResponseBody>> doubleNull(@Query("doubleQuery") Double doubleQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/string/unicode/")
        Observable<Response<ResponseBody>> stringUnicode(@Query("stringQuery") String stringQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/string/begin%21%2A%27%28%29%3B%3A%40%20%26%3D%2B%24%2C%2F%3F%23%5B%5Dend")
        Observable<Response<ResponseBody>> stringUrlEncoded(@Query("stringQuery") String stringQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/string/empty")
        Observable<Response<ResponseBody>> stringEmpty(@Query("stringQuery") String stringQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/string/null")
        Observable<Response<ResponseBody>> stringNull(@Query("stringQuery") String stringQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/enum/green%20color")
        Observable<Response<ResponseBody>> enumValid(@Query("enumQuery") UriColor enumQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/enum/null")
        Observable<Response<ResponseBody>> enumNull(@Query("enumQuery") UriColor enumQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/byte/multibyte")
        Observable<Response<ResponseBody>> byteMultiByte(@Query("byteQuery") String byteQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/byte/empty")
        Observable<Response<ResponseBody>> byteEmpty(@Query("byteQuery") String byteQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/byte/null")
        Observable<Response<ResponseBody>> byteNull(@Query("byteQuery") String byteQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/date/2012-01-01")
        Observable<Response<ResponseBody>> dateValid(@Query("dateQuery") LocalDate dateQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/date/null")
        Observable<Response<ResponseBody>> dateNull(@Query("dateQuery") LocalDate dateQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/datetime/2012-01-01T01%3A01%3A01Z")
        Observable<Response<ResponseBody>> dateTimeValid(@Query("dateTimeQuery") DateTime dateTimeQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/datetime/null")
        Observable<Response<ResponseBody>> dateTimeNull(@Query("dateTimeQuery") DateTime dateTimeQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/array/csv/string/valid")
        Observable<Response<ResponseBody>> arrayStringCsvValid(@Query("arrayQuery") String arrayQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/array/csv/string/null")
        Observable<Response<ResponseBody>> arrayStringCsvNull(@Query("arrayQuery") String arrayQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/array/csv/string/empty")
        Observable<Response<ResponseBody>> arrayStringCsvEmpty(@Query("arrayQuery") String arrayQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/array/ssv/string/valid")
        Observable<Response<ResponseBody>> arrayStringSsvValid(@Query("arrayQuery") String arrayQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/array/tsv/string/valid")
        Observable<Response<ResponseBody>> arrayStringTsvValid(@Query("arrayQuery") String arrayQuery);

        @Headers("Content-Type: application/json; charset=utf-8")
        @GET("queries/array/pipes/string/valid")
        Observable<Response<ResponseBody>> arrayStringPipesValid(@Query("arrayQuery") String arrayQuery);

    }

    /**
     * Get true Boolean value on path.
     *
     */
    public void getBooleanTrue() {
        getBooleanTrueWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get true Boolean value on path.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> getBooleanTrueAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(getBooleanTrueWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get true Boolean value on path.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> getBooleanTrueAsync() {
        return getBooleanTrueWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get true Boolean value on path.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> getBooleanTrueWithServiceResponseAsync() {
        final boolean boolQuery = true;
        return service.getBooleanTrue(boolQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = getBooleanTrueDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> getBooleanTrueDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get false Boolean value on path.
     *
     */
    public void getBooleanFalse() {
        getBooleanFalseWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get false Boolean value on path.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> getBooleanFalseAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(getBooleanFalseWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get false Boolean value on path.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> getBooleanFalseAsync() {
        return getBooleanFalseWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get false Boolean value on path.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> getBooleanFalseWithServiceResponseAsync() {
        final boolean boolQuery = false;
        return service.getBooleanFalse(boolQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = getBooleanFalseDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> getBooleanFalseDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get null Boolean value on query (query string should be absent).
     *
     */
    public void getBooleanNull() {
        getBooleanNullWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get null Boolean value on query (query string should be absent).
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> getBooleanNullAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(getBooleanNullWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get null Boolean value on query (query string should be absent).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> getBooleanNullAsync() {
        return getBooleanNullWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null Boolean value on query (query string should be absent).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> getBooleanNullWithServiceResponseAsync() {
        final Boolean boolQuery = null;
        return service.getBooleanNull(boolQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = getBooleanNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get null Boolean value on query (query string should be absent).
     *
     * @param boolQuery null boolean value
     */
    public void getBooleanNull(Boolean boolQuery) {
        getBooleanNullWithServiceResponseAsync(boolQuery).toBlocking().single().getBody();
    }

    /**
     * Get null Boolean value on query (query string should be absent).
     *
     * @param boolQuery null boolean value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> getBooleanNullAsync(Boolean boolQuery, final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(getBooleanNullWithServiceResponseAsync(boolQuery), serviceCallback);
    }

    /**
     * Get null Boolean value on query (query string should be absent).
     *
     * @param boolQuery null boolean value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> getBooleanNullAsync(Boolean boolQuery) {
        return getBooleanNullWithServiceResponseAsync(boolQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null Boolean value on query (query string should be absent).
     *
     * @param boolQuery null boolean value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> getBooleanNullWithServiceResponseAsync(Boolean boolQuery) {
        return service.getBooleanNull(boolQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = getBooleanNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> getBooleanNullDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '1000000' integer value.
     *
     */
    public void getIntOneMillion() {
        getIntOneMillionWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '1000000' integer value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> getIntOneMillionAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(getIntOneMillionWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '1000000' integer value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> getIntOneMillionAsync() {
        return getIntOneMillionWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '1000000' integer value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> getIntOneMillionWithServiceResponseAsync() {
        final int intQuery = 1000000;
        return service.getIntOneMillion(intQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = getIntOneMillionDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> getIntOneMillionDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '-1000000' integer value.
     *
     */
    public void getIntNegativeOneMillion() {
        getIntNegativeOneMillionWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '-1000000' integer value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> getIntNegativeOneMillionAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(getIntNegativeOneMillionWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '-1000000' integer value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> getIntNegativeOneMillionAsync() {
        return getIntNegativeOneMillionWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '-1000000' integer value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> getIntNegativeOneMillionWithServiceResponseAsync() {
        final int intQuery = -1000000;
        return service.getIntNegativeOneMillion(intQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = getIntNegativeOneMillionDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> getIntNegativeOneMillionDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get null integer value (no query parameter).
     *
     */
    public void getIntNull() {
        getIntNullWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get null integer value (no query parameter).
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> getIntNullAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(getIntNullWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get null integer value (no query parameter).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> getIntNullAsync() {
        return getIntNullWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null integer value (no query parameter).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> getIntNullWithServiceResponseAsync() {
        final Integer intQuery = null;
        return service.getIntNull(intQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = getIntNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get null integer value (no query parameter).
     *
     * @param intQuery null integer value
     */
    public void getIntNull(Integer intQuery) {
        getIntNullWithServiceResponseAsync(intQuery).toBlocking().single().getBody();
    }

    /**
     * Get null integer value (no query parameter).
     *
     * @param intQuery null integer value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> getIntNullAsync(Integer intQuery, final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(getIntNullWithServiceResponseAsync(intQuery), serviceCallback);
    }

    /**
     * Get null integer value (no query parameter).
     *
     * @param intQuery null integer value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> getIntNullAsync(Integer intQuery) {
        return getIntNullWithServiceResponseAsync(intQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null integer value (no query parameter).
     *
     * @param intQuery null integer value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> getIntNullWithServiceResponseAsync(Integer intQuery) {
        return service.getIntNull(intQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = getIntNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> getIntNullDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '10000000000' 64 bit integer value.
     *
     */
    public void getTenBillion() {
        getTenBillionWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '10000000000' 64 bit integer value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> getTenBillionAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(getTenBillionWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '10000000000' 64 bit integer value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> getTenBillionAsync() {
        return getTenBillionWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '10000000000' 64 bit integer value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> getTenBillionWithServiceResponseAsync() {
        final long longQuery = 10000000000L;
        return service.getTenBillion(longQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = getTenBillionDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> getTenBillionDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '-10000000000' 64 bit integer value.
     *
     */
    public void getNegativeTenBillion() {
        getNegativeTenBillionWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '-10000000000' 64 bit integer value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> getNegativeTenBillionAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(getNegativeTenBillionWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '-10000000000' 64 bit integer value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> getNegativeTenBillionAsync() {
        return getNegativeTenBillionWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '-10000000000' 64 bit integer value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> getNegativeTenBillionWithServiceResponseAsync() {
        final long longQuery = -10000000000L;
        return service.getNegativeTenBillion(longQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = getNegativeTenBillionDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> getNegativeTenBillionDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get 'null 64 bit integer value (no query param in uri).
     *
     */
    public void getLongNull() {
        getLongNullWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get 'null 64 bit integer value (no query param in uri).
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> getLongNullAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(getLongNullWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get 'null 64 bit integer value (no query param in uri).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> getLongNullAsync() {
        return getLongNullWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get 'null 64 bit integer value (no query param in uri).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> getLongNullWithServiceResponseAsync() {
        final Long longQuery = null;
        return service.getLongNull(longQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = getLongNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get 'null 64 bit integer value (no query param in uri).
     *
     * @param longQuery null 64 bit integer value
     */
    public void getLongNull(Long longQuery) {
        getLongNullWithServiceResponseAsync(longQuery).toBlocking().single().getBody();
    }

    /**
     * Get 'null 64 bit integer value (no query param in uri).
     *
     * @param longQuery null 64 bit integer value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> getLongNullAsync(Long longQuery, final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(getLongNullWithServiceResponseAsync(longQuery), serviceCallback);
    }

    /**
     * Get 'null 64 bit integer value (no query param in uri).
     *
     * @param longQuery null 64 bit integer value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> getLongNullAsync(Long longQuery) {
        return getLongNullWithServiceResponseAsync(longQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get 'null 64 bit integer value (no query param in uri).
     *
     * @param longQuery null 64 bit integer value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> getLongNullWithServiceResponseAsync(Long longQuery) {
        return service.getLongNull(longQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = getLongNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> getLongNullDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '1.034E+20' numeric value.
     *
     */
    public void floatScientificPositive() {
        floatScientificPositiveWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '1.034E+20' numeric value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> floatScientificPositiveAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(floatScientificPositiveWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '1.034E+20' numeric value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> floatScientificPositiveAsync() {
        return floatScientificPositiveWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '1.034E+20' numeric value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> floatScientificPositiveWithServiceResponseAsync() {
        final double floatQuery = 1.034E+20;
        return service.floatScientificPositive(floatQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = floatScientificPositiveDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> floatScientificPositiveDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '-1.034E-20' numeric value.
     *
     */
    public void floatScientificNegative() {
        floatScientificNegativeWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '-1.034E-20' numeric value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> floatScientificNegativeAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(floatScientificNegativeWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '-1.034E-20' numeric value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> floatScientificNegativeAsync() {
        return floatScientificNegativeWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '-1.034E-20' numeric value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> floatScientificNegativeWithServiceResponseAsync() {
        final double floatQuery = -1.034E-20;
        return service.floatScientificNegative(floatQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = floatScientificNegativeDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> floatScientificNegativeDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get null numeric value (no query parameter).
     *
     */
    public void floatNull() {
        floatNullWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> floatNullAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(floatNullWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> floatNullAsync() {
        return floatNullWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> floatNullWithServiceResponseAsync() {
        final Double floatQuery = null;
        return service.floatNull(floatQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = floatNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @param floatQuery null numeric value
     */
    public void floatNull(Double floatQuery) {
        floatNullWithServiceResponseAsync(floatQuery).toBlocking().single().getBody();
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @param floatQuery null numeric value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> floatNullAsync(Double floatQuery, final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(floatNullWithServiceResponseAsync(floatQuery), serviceCallback);
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @param floatQuery null numeric value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> floatNullAsync(Double floatQuery) {
        return floatNullWithServiceResponseAsync(floatQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @param floatQuery null numeric value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> floatNullWithServiceResponseAsync(Double floatQuery) {
        return service.floatNull(floatQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = floatNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> floatNullDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '9999999.999' numeric value.
     *
     */
    public void doubleDecimalPositive() {
        doubleDecimalPositiveWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '9999999.999' numeric value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> doubleDecimalPositiveAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(doubleDecimalPositiveWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '9999999.999' numeric value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> doubleDecimalPositiveAsync() {
        return doubleDecimalPositiveWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '9999999.999' numeric value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> doubleDecimalPositiveWithServiceResponseAsync() {
        final double doubleQuery = 9999999.999;
        return service.doubleDecimalPositive(doubleQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = doubleDecimalPositiveDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> doubleDecimalPositiveDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '-9999999.999' numeric value.
     *
     */
    public void doubleDecimalNegative() {
        doubleDecimalNegativeWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '-9999999.999' numeric value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> doubleDecimalNegativeAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(doubleDecimalNegativeWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '-9999999.999' numeric value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> doubleDecimalNegativeAsync() {
        return doubleDecimalNegativeWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '-9999999.999' numeric value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> doubleDecimalNegativeWithServiceResponseAsync() {
        final double doubleQuery = -9999999.999;
        return service.doubleDecimalNegative(doubleQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = doubleDecimalNegativeDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> doubleDecimalNegativeDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get null numeric value (no query parameter).
     *
     */
    public void doubleNull() {
        doubleNullWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> doubleNullAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(doubleNullWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> doubleNullAsync() {
        return doubleNullWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> doubleNullWithServiceResponseAsync() {
        final Double doubleQuery = null;
        return service.doubleNull(doubleQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = doubleNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @param doubleQuery null numeric value
     */
    public void doubleNull(Double doubleQuery) {
        doubleNullWithServiceResponseAsync(doubleQuery).toBlocking().single().getBody();
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @param doubleQuery null numeric value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> doubleNullAsync(Double doubleQuery, final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(doubleNullWithServiceResponseAsync(doubleQuery), serviceCallback);
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @param doubleQuery null numeric value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> doubleNullAsync(Double doubleQuery) {
        return doubleNullWithServiceResponseAsync(doubleQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null numeric value (no query parameter).
     *
     * @param doubleQuery null numeric value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> doubleNullWithServiceResponseAsync(Double doubleQuery) {
        return service.doubleNull(doubleQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = doubleNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> doubleNullDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '' multi-byte string value.
     *
     */
    public void stringUnicode() {
        stringUnicodeWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '' multi-byte string value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> stringUnicodeAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(stringUnicodeWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '' multi-byte string value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> stringUnicodeAsync() {
        return stringUnicodeWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '' multi-byte string value.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> stringUnicodeWithServiceResponseAsync() {
        final String stringQuery = "";
        return service.stringUnicode(stringQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = stringUnicodeDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> stringUnicodeDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get 'begin!*'();:@ &amp;=+$,/?#[]end.
     *
     */
    public void stringUrlEncoded() {
        stringUrlEncodedWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get 'begin!*'();:@ &amp;=+$,/?#[]end.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> stringUrlEncodedAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(stringUrlEncodedWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get 'begin!*'();:@ &amp;=+$,/?#[]end.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> stringUrlEncodedAsync() {
        return stringUrlEncodedWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get 'begin!*'();:@ &amp;=+$,/?#[]end.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> stringUrlEncodedWithServiceResponseAsync() {
        final String stringQuery = "begin!*'();:@ &=+$,/?#[]end";
        return service.stringUrlEncoded(stringQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = stringUrlEncodedDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> stringUrlEncodedDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get ''.
     *
     */
    public void stringEmpty() {
        stringEmptyWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get ''.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> stringEmptyAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(stringEmptyWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get ''.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> stringEmptyAsync() {
        return stringEmptyWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get ''.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> stringEmptyWithServiceResponseAsync() {
        final String stringQuery = "";
        return service.stringEmpty(stringQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = stringEmptyDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> stringEmptyDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get null (no query parameter in url).
     *
     */
    public void stringNull() {
        stringNullWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get null (no query parameter in url).
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> stringNullAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(stringNullWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get null (no query parameter in url).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> stringNullAsync() {
        return stringNullWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null (no query parameter in url).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> stringNullWithServiceResponseAsync() {
        final String stringQuery = null;
        return service.stringNull(stringQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = stringNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get null (no query parameter in url).
     *
     * @param stringQuery null string value
     */
    public void stringNull(String stringQuery) {
        stringNullWithServiceResponseAsync(stringQuery).toBlocking().single().getBody();
    }

    /**
     * Get null (no query parameter in url).
     *
     * @param stringQuery null string value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> stringNullAsync(String stringQuery, final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(stringNullWithServiceResponseAsync(stringQuery), serviceCallback);
    }

    /**
     * Get null (no query parameter in url).
     *
     * @param stringQuery null string value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> stringNullAsync(String stringQuery) {
        return stringNullWithServiceResponseAsync(stringQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null (no query parameter in url).
     *
     * @param stringQuery null string value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> stringNullWithServiceResponseAsync(String stringQuery) {
        return service.stringNull(stringQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = stringNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> stringNullDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get using uri with query parameter 'green color'.
     *
     */
    public void enumValid() {
        enumValidWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get using uri with query parameter 'green color'.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> enumValidAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(enumValidWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get using uri with query parameter 'green color'.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> enumValidAsync() {
        return enumValidWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get using uri with query parameter 'green color'.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> enumValidWithServiceResponseAsync() {
        final UriColor enumQuery = null;
        return service.enumValid(enumQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = enumValidDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get using uri with query parameter 'green color'.
     *
     * @param enumQuery 'green color' enum value. Possible values include: 'red color', 'green color', 'blue color'
     */
    public void enumValid(UriColor enumQuery) {
        enumValidWithServiceResponseAsync(enumQuery).toBlocking().single().getBody();
    }

    /**
     * Get using uri with query parameter 'green color'.
     *
     * @param enumQuery 'green color' enum value. Possible values include: 'red color', 'green color', 'blue color'
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> enumValidAsync(UriColor enumQuery, final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(enumValidWithServiceResponseAsync(enumQuery), serviceCallback);
    }

    /**
     * Get using uri with query parameter 'green color'.
     *
     * @param enumQuery 'green color' enum value. Possible values include: 'red color', 'green color', 'blue color'
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> enumValidAsync(UriColor enumQuery) {
        return enumValidWithServiceResponseAsync(enumQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get using uri with query parameter 'green color'.
     *
     * @param enumQuery 'green color' enum value. Possible values include: 'red color', 'green color', 'blue color'
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> enumValidWithServiceResponseAsync(UriColor enumQuery) {
        return service.enumValid(enumQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = enumValidDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> enumValidDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get null (no query parameter in url).
     *
     */
    public void enumNull() {
        enumNullWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get null (no query parameter in url).
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> enumNullAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(enumNullWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get null (no query parameter in url).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> enumNullAsync() {
        return enumNullWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null (no query parameter in url).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> enumNullWithServiceResponseAsync() {
        final UriColor enumQuery = null;
        return service.enumNull(enumQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = enumNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get null (no query parameter in url).
     *
     * @param enumQuery null string value. Possible values include: 'red color', 'green color', 'blue color'
     */
    public void enumNull(UriColor enumQuery) {
        enumNullWithServiceResponseAsync(enumQuery).toBlocking().single().getBody();
    }

    /**
     * Get null (no query parameter in url).
     *
     * @param enumQuery null string value. Possible values include: 'red color', 'green color', 'blue color'
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> enumNullAsync(UriColor enumQuery, final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(enumNullWithServiceResponseAsync(enumQuery), serviceCallback);
    }

    /**
     * Get null (no query parameter in url).
     *
     * @param enumQuery null string value. Possible values include: 'red color', 'green color', 'blue color'
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> enumNullAsync(UriColor enumQuery) {
        return enumNullWithServiceResponseAsync(enumQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null (no query parameter in url).
     *
     * @param enumQuery null string value. Possible values include: 'red color', 'green color', 'blue color'
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> enumNullWithServiceResponseAsync(UriColor enumQuery) {
        return service.enumNull(enumQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = enumNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> enumNullDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '' multibyte value as utf-8 encoded byte array.
     *
     */
    public void byteMultiByte() {
        byteMultiByteWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '' multibyte value as utf-8 encoded byte array.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> byteMultiByteAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(byteMultiByteWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '' multibyte value as utf-8 encoded byte array.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> byteMultiByteAsync() {
        return byteMultiByteWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '' multibyte value as utf-8 encoded byte array.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> byteMultiByteWithServiceResponseAsync() {
        final byte[] byteQuery = new byte[0];
        String byteQueryConverted = Base64.encodeBase64String(byteQuery);
        return service.byteMultiByte(byteQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = byteMultiByteDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get '' multibyte value as utf-8 encoded byte array.
     *
     * @param byteQuery '' multibyte value as utf-8 encoded byte array
     */
    public void byteMultiByte(byte[] byteQuery) {
        byteMultiByteWithServiceResponseAsync(byteQuery).toBlocking().single().getBody();
    }

    /**
     * Get '' multibyte value as utf-8 encoded byte array.
     *
     * @param byteQuery '' multibyte value as utf-8 encoded byte array
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> byteMultiByteAsync(byte[] byteQuery, final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(byteMultiByteWithServiceResponseAsync(byteQuery), serviceCallback);
    }

    /**
     * Get '' multibyte value as utf-8 encoded byte array.
     *
     * @param byteQuery '' multibyte value as utf-8 encoded byte array
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> byteMultiByteAsync(byte[] byteQuery) {
        return byteMultiByteWithServiceResponseAsync(byteQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '' multibyte value as utf-8 encoded byte array.
     *
     * @param byteQuery '' multibyte value as utf-8 encoded byte array
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> byteMultiByteWithServiceResponseAsync(byte[] byteQuery) {
        String byteQueryConverted = Base64.encodeBase64String(byteQuery);
        return service.byteMultiByte(byteQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = byteMultiByteDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> byteMultiByteDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '' as byte array.
     *
     */
    public void byteEmpty() {
        byteEmptyWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '' as byte array.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> byteEmptyAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(byteEmptyWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '' as byte array.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> byteEmptyAsync() {
        return byteEmptyWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '' as byte array.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> byteEmptyWithServiceResponseAsync() {
        final byte[] byteQuery = "".getBytes();
        String byteQueryConverted = Base64.encodeBase64String(byteQuery);
        return service.byteEmpty(byteQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = byteEmptyDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> byteEmptyDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get null as byte array (no query parameters in uri).
     *
     */
    public void byteNull() {
        byteNullWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get null as byte array (no query parameters in uri).
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> byteNullAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(byteNullWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get null as byte array (no query parameters in uri).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> byteNullAsync() {
        return byteNullWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null as byte array (no query parameters in uri).
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> byteNullWithServiceResponseAsync() {
        final byte[] byteQuery = new byte[0];
        String byteQueryConverted = Base64.encodeBase64String(byteQuery);
        return service.byteNull(byteQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = byteNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get null as byte array (no query parameters in uri).
     *
     * @param byteQuery null as byte array (no query parameters in uri)
     */
    public void byteNull(byte[] byteQuery) {
        byteNullWithServiceResponseAsync(byteQuery).toBlocking().single().getBody();
    }

    /**
     * Get null as byte array (no query parameters in uri).
     *
     * @param byteQuery null as byte array (no query parameters in uri)
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> byteNullAsync(byte[] byteQuery, final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(byteNullWithServiceResponseAsync(byteQuery), serviceCallback);
    }

    /**
     * Get null as byte array (no query parameters in uri).
     *
     * @param byteQuery null as byte array (no query parameters in uri)
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> byteNullAsync(byte[] byteQuery) {
        return byteNullWithServiceResponseAsync(byteQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null as byte array (no query parameters in uri).
     *
     * @param byteQuery null as byte array (no query parameters in uri)
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> byteNullWithServiceResponseAsync(byte[] byteQuery) {
        String byteQueryConverted = Base64.encodeBase64String(byteQuery);
        return service.byteNull(byteQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = byteNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> byteNullDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '2012-01-01' as date.
     *
     */
    public void dateValid() {
        dateValidWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '2012-01-01' as date.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> dateValidAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(dateValidWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '2012-01-01' as date.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> dateValidAsync() {
        return dateValidWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '2012-01-01' as date.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> dateValidWithServiceResponseAsync() {
        final LocalDate dateQuery = LocalDate.parse("2012-01-01");
        return service.dateValid(dateQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = dateValidDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> dateValidDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get null as date - this should result in no query parameters in uri.
     *
     */
    public void dateNull() {
        dateNullWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get null as date - this should result in no query parameters in uri.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> dateNullAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(dateNullWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get null as date - this should result in no query parameters in uri.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> dateNullAsync() {
        return dateNullWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null as date - this should result in no query parameters in uri.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> dateNullWithServiceResponseAsync() {
        final LocalDate dateQuery = null;
        return service.dateNull(dateQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = dateNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get null as date - this should result in no query parameters in uri.
     *
     * @param dateQuery null as date (no query parameters in uri)
     */
    public void dateNull(LocalDate dateQuery) {
        dateNullWithServiceResponseAsync(dateQuery).toBlocking().single().getBody();
    }

    /**
     * Get null as date - this should result in no query parameters in uri.
     *
     * @param dateQuery null as date (no query parameters in uri)
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> dateNullAsync(LocalDate dateQuery, final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(dateNullWithServiceResponseAsync(dateQuery), serviceCallback);
    }

    /**
     * Get null as date - this should result in no query parameters in uri.
     *
     * @param dateQuery null as date (no query parameters in uri)
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> dateNullAsync(LocalDate dateQuery) {
        return dateNullWithServiceResponseAsync(dateQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null as date - this should result in no query parameters in uri.
     *
     * @param dateQuery null as date (no query parameters in uri)
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> dateNullWithServiceResponseAsync(LocalDate dateQuery) {
        return service.dateNull(dateQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = dateNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> dateNullDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get '2012-01-01T01:01:01Z' as date-time.
     *
     */
    public void dateTimeValid() {
        dateTimeValidWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get '2012-01-01T01:01:01Z' as date-time.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> dateTimeValidAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(dateTimeValidWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get '2012-01-01T01:01:01Z' as date-time.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> dateTimeValidAsync() {
        return dateTimeValidWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get '2012-01-01T01:01:01Z' as date-time.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> dateTimeValidWithServiceResponseAsync() {
        final DateTime dateTimeQuery = DateTime.parse("2012-01-01T01:01:01Z");
        return service.dateTimeValid(dateTimeQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = dateTimeValidDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> dateTimeValidDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get null as date-time, should result in no query parameters in uri.
     *
     */
    public void dateTimeNull() {
        dateTimeNullWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get null as date-time, should result in no query parameters in uri.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> dateTimeNullAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(dateTimeNullWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get null as date-time, should result in no query parameters in uri.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> dateTimeNullAsync() {
        return dateTimeNullWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null as date-time, should result in no query parameters in uri.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> dateTimeNullWithServiceResponseAsync() {
        final DateTime dateTimeQuery = null;
        return service.dateTimeNull(dateTimeQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = dateTimeNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get null as date-time, should result in no query parameters in uri.
     *
     * @param dateTimeQuery null as date-time (no query parameters)
     */
    public void dateTimeNull(DateTime dateTimeQuery) {
        dateTimeNullWithServiceResponseAsync(dateTimeQuery).toBlocking().single().getBody();
    }

    /**
     * Get null as date-time, should result in no query parameters in uri.
     *
     * @param dateTimeQuery null as date-time (no query parameters)
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> dateTimeNullAsync(DateTime dateTimeQuery,
            final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(dateTimeNullWithServiceResponseAsync(dateTimeQuery), serviceCallback);
    }

    /**
     * Get null as date-time, should result in no query parameters in uri.
     *
     * @param dateTimeQuery null as date-time (no query parameters)
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> dateTimeNullAsync(DateTime dateTimeQuery) {
        return dateTimeNullWithServiceResponseAsync(dateTimeQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get null as date-time, should result in no query parameters in uri.
     *
     * @param dateTimeQuery null as date-time (no query parameters)
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> dateTimeNullWithServiceResponseAsync(DateTime dateTimeQuery) {
        return service.dateTimeNull(dateTimeQuery)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = dateTimeNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> dateTimeNullDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the csv-array format.
     *
     */
    public void arrayStringCsvValid() {
        arrayStringCsvValidWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the csv-array format.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> arrayStringCsvValidAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(arrayStringCsvValidWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the csv-array format.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> arrayStringCsvValidAsync() {
        return arrayStringCsvValidWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the csv-array format.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> arrayStringCsvValidWithServiceResponseAsync() {
        final List<String> arrayQuery = null;
        String arrayQueryConverted = this.client.mapperAdapter().serializeList(arrayQuery, CollectionFormat.CSV);
        return service.arrayStringCsvValid(arrayQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = arrayStringCsvValidDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the csv-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the csv-array format
     */
    public void arrayStringCsvValid(List<String> arrayQuery) {
        arrayStringCsvValidWithServiceResponseAsync(arrayQuery).toBlocking().single().getBody();
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the csv-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the csv-array format
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> arrayStringCsvValidAsync(List<String> arrayQuery,
            final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(arrayStringCsvValidWithServiceResponseAsync(arrayQuery), serviceCallback);
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the csv-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the csv-array format
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> arrayStringCsvValidAsync(List<String> arrayQuery) {
        return arrayStringCsvValidWithServiceResponseAsync(arrayQuery)
                .map(new Func1<ServiceResponse<Void>, Void>() {
                    @Override
                    public Void call(ServiceResponse<Void> response) {
                        return response.getBody();
                    }
                });
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the csv-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the csv-array format
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> arrayStringCsvValidWithServiceResponseAsync(List<String> arrayQuery) {
        Validator.validate(arrayQuery);
        String arrayQueryConverted = this.client.mapperAdapter().serializeList(arrayQuery, CollectionFormat.CSV);
        return service.arrayStringCsvValid(arrayQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = arrayStringCsvValidDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> arrayStringCsvValidDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get a null array of string using the csv-array format.
     *
     */
    public void arrayStringCsvNull() {
        arrayStringCsvNullWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get a null array of string using the csv-array format.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> arrayStringCsvNullAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(arrayStringCsvNullWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get a null array of string using the csv-array format.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> arrayStringCsvNullAsync() {
        return arrayStringCsvNullWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get a null array of string using the csv-array format.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> arrayStringCsvNullWithServiceResponseAsync() {
        final List<String> arrayQuery = null;
        String arrayQueryConverted = this.client.mapperAdapter().serializeList(arrayQuery, CollectionFormat.CSV);
        return service.arrayStringCsvNull(arrayQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = arrayStringCsvNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get a null array of string using the csv-array format.
     *
     * @param arrayQuery a null array of string using the csv-array format
     */
    public void arrayStringCsvNull(List<String> arrayQuery) {
        arrayStringCsvNullWithServiceResponseAsync(arrayQuery).toBlocking().single().getBody();
    }

    /**
     * Get a null array of string using the csv-array format.
     *
     * @param arrayQuery a null array of string using the csv-array format
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> arrayStringCsvNullAsync(List<String> arrayQuery,
            final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(arrayStringCsvNullWithServiceResponseAsync(arrayQuery), serviceCallback);
    }

    /**
     * Get a null array of string using the csv-array format.
     *
     * @param arrayQuery a null array of string using the csv-array format
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> arrayStringCsvNullAsync(List<String> arrayQuery) {
        return arrayStringCsvNullWithServiceResponseAsync(arrayQuery).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get a null array of string using the csv-array format.
     *
     * @param arrayQuery a null array of string using the csv-array format
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> arrayStringCsvNullWithServiceResponseAsync(List<String> arrayQuery) {
        Validator.validate(arrayQuery);
        String arrayQueryConverted = this.client.mapperAdapter().serializeList(arrayQuery, CollectionFormat.CSV);
        return service.arrayStringCsvNull(arrayQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = arrayStringCsvNullDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> arrayStringCsvNullDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get an empty array [] of string using the csv-array format.
     *
     */
    public void arrayStringCsvEmpty() {
        arrayStringCsvEmptyWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get an empty array [] of string using the csv-array format.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> arrayStringCsvEmptyAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(arrayStringCsvEmptyWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get an empty array [] of string using the csv-array format.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> arrayStringCsvEmptyAsync() {
        return arrayStringCsvEmptyWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get an empty array [] of string using the csv-array format.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> arrayStringCsvEmptyWithServiceResponseAsync() {
        final List<String> arrayQuery = null;
        String arrayQueryConverted = this.client.mapperAdapter().serializeList(arrayQuery, CollectionFormat.CSV);
        return service.arrayStringCsvEmpty(arrayQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = arrayStringCsvEmptyDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get an empty array [] of string using the csv-array format.
     *
     * @param arrayQuery an empty array [] of string using the csv-array format
     */
    public void arrayStringCsvEmpty(List<String> arrayQuery) {
        arrayStringCsvEmptyWithServiceResponseAsync(arrayQuery).toBlocking().single().getBody();
    }

    /**
     * Get an empty array [] of string using the csv-array format.
     *
     * @param arrayQuery an empty array [] of string using the csv-array format
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> arrayStringCsvEmptyAsync(List<String> arrayQuery,
            final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(arrayStringCsvEmptyWithServiceResponseAsync(arrayQuery), serviceCallback);
    }

    /**
     * Get an empty array [] of string using the csv-array format.
     *
     * @param arrayQuery an empty array [] of string using the csv-array format
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> arrayStringCsvEmptyAsync(List<String> arrayQuery) {
        return arrayStringCsvEmptyWithServiceResponseAsync(arrayQuery)
                .map(new Func1<ServiceResponse<Void>, Void>() {
                    @Override
                    public Void call(ServiceResponse<Void> response) {
                        return response.getBody();
                    }
                });
    }

    /**
     * Get an empty array [] of string using the csv-array format.
     *
     * @param arrayQuery an empty array [] of string using the csv-array format
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> arrayStringCsvEmptyWithServiceResponseAsync(List<String> arrayQuery) {
        Validator.validate(arrayQuery);
        String arrayQueryConverted = this.client.mapperAdapter().serializeList(arrayQuery, CollectionFormat.CSV);
        return service.arrayStringCsvEmpty(arrayQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = arrayStringCsvEmptyDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> arrayStringCsvEmptyDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the ssv-array format.
     *
     */
    public void arrayStringSsvValid() {
        arrayStringSsvValidWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the ssv-array format.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> arrayStringSsvValidAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(arrayStringSsvValidWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the ssv-array format.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> arrayStringSsvValidAsync() {
        return arrayStringSsvValidWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the ssv-array format.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> arrayStringSsvValidWithServiceResponseAsync() {
        final List<String> arrayQuery = null;
        String arrayQueryConverted = this.client.mapperAdapter().serializeList(arrayQuery, CollectionFormat.SSV);
        return service.arrayStringSsvValid(arrayQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = arrayStringSsvValidDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the ssv-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the ssv-array format
     */
    public void arrayStringSsvValid(List<String> arrayQuery) {
        arrayStringSsvValidWithServiceResponseAsync(arrayQuery).toBlocking().single().getBody();
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the ssv-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the ssv-array format
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> arrayStringSsvValidAsync(List<String> arrayQuery,
            final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(arrayStringSsvValidWithServiceResponseAsync(arrayQuery), serviceCallback);
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the ssv-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the ssv-array format
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> arrayStringSsvValidAsync(List<String> arrayQuery) {
        return arrayStringSsvValidWithServiceResponseAsync(arrayQuery)
                .map(new Func1<ServiceResponse<Void>, Void>() {
                    @Override
                    public Void call(ServiceResponse<Void> response) {
                        return response.getBody();
                    }
                });
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the ssv-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the ssv-array format
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> arrayStringSsvValidWithServiceResponseAsync(List<String> arrayQuery) {
        Validator.validate(arrayQuery);
        String arrayQueryConverted = this.client.mapperAdapter().serializeList(arrayQuery, CollectionFormat.SSV);
        return service.arrayStringSsvValid(arrayQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = arrayStringSsvValidDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> arrayStringSsvValidDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the tsv-array format.
     *
     */
    public void arrayStringTsvValid() {
        arrayStringTsvValidWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the tsv-array format.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> arrayStringTsvValidAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(arrayStringTsvValidWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the tsv-array format.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> arrayStringTsvValidAsync() {
        return arrayStringTsvValidWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the tsv-array format.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> arrayStringTsvValidWithServiceResponseAsync() {
        final List<String> arrayQuery = null;
        String arrayQueryConverted = this.client.mapperAdapter().serializeList(arrayQuery, CollectionFormat.TSV);
        return service.arrayStringTsvValid(arrayQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = arrayStringTsvValidDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the tsv-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the tsv-array format
     */
    public void arrayStringTsvValid(List<String> arrayQuery) {
        arrayStringTsvValidWithServiceResponseAsync(arrayQuery).toBlocking().single().getBody();
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the tsv-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the tsv-array format
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> arrayStringTsvValidAsync(List<String> arrayQuery,
            final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(arrayStringTsvValidWithServiceResponseAsync(arrayQuery), serviceCallback);
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the tsv-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the tsv-array format
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> arrayStringTsvValidAsync(List<String> arrayQuery) {
        return arrayStringTsvValidWithServiceResponseAsync(arrayQuery)
                .map(new Func1<ServiceResponse<Void>, Void>() {
                    @Override
                    public Void call(ServiceResponse<Void> response) {
                        return response.getBody();
                    }
                });
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the tsv-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the tsv-array format
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> arrayStringTsvValidWithServiceResponseAsync(List<String> arrayQuery) {
        Validator.validate(arrayQuery);
        String arrayQueryConverted = this.client.mapperAdapter().serializeList(arrayQuery, CollectionFormat.TSV);
        return service.arrayStringTsvValid(arrayQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = arrayStringTsvValidDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> arrayStringTsvValidDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the pipes-array format.
     *
     */
    public void arrayStringPipesValid() {
        arrayStringPipesValidWithServiceResponseAsync().toBlocking().single().getBody();
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the pipes-array format.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> arrayStringPipesValidAsync(final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(arrayStringPipesValidWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the pipes-array format.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> arrayStringPipesValidAsync() {
        return arrayStringPipesValidWithServiceResponseAsync().map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.getBody();
            }
        });
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the pipes-array format.
     *
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> arrayStringPipesValidWithServiceResponseAsync() {
        final List<String> arrayQuery = null;
        String arrayQueryConverted = this.client.mapperAdapter().serializeList(arrayQuery, CollectionFormat.PIPES);
        return service.arrayStringPipesValid(arrayQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = arrayStringPipesValidDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the pipes-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the pipes-array format
     */
    public void arrayStringPipesValid(List<String> arrayQuery) {
        arrayStringPipesValidWithServiceResponseAsync(arrayQuery).toBlocking().single().getBody();
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the pipes-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the pipes-array format
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceCall} object
     */
    public ServiceCall<Void> arrayStringPipesValidAsync(List<String> arrayQuery,
            final ServiceCallback<Void> serviceCallback) {
        return ServiceCall.create(arrayStringPipesValidWithServiceResponseAsync(arrayQuery), serviceCallback);
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the pipes-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the pipes-array format
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> arrayStringPipesValidAsync(List<String> arrayQuery) {
        return arrayStringPipesValidWithServiceResponseAsync(arrayQuery)
                .map(new Func1<ServiceResponse<Void>, Void>() {
                    @Override
                    public Void call(ServiceResponse<Void> response) {
                        return response.getBody();
                    }
                });
    }

    /**
     * Get an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the pipes-array format.
     *
     * @param arrayQuery an array of string ['ArrayQuery1', 'begin!*'();:@ &amp;=+$,/?#[]end' , null, ''] using the pipes-array format
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> arrayStringPipesValidWithServiceResponseAsync(
            List<String> arrayQuery) {
        Validator.validate(arrayQuery);
        String arrayQueryConverted = this.client.mapperAdapter().serializeList(arrayQuery, CollectionFormat.PIPES);
        return service.arrayStringPipesValid(arrayQueryConverted)
                .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                    @Override
                    public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                        try {
                            ServiceResponse<Void> clientResponse = arrayStringPipesValidDelegate(response);
                            return Observable.just(clientResponse);
                        } catch (Throwable t) {
                            return Observable.error(t);
                        }
                    }
                });
    }

    private ServiceResponse<Void> arrayStringPipesValidDelegate(Response<ResponseBody> response)
            throws ErrorException, IOException {
        return new ServiceResponseBuilder<Void, ErrorException>(this.client.mapperAdapter())
                .register(200, new TypeToken<Void>() {
                }.getType()).registerError(ErrorException.class).build(response);
    }

}