fixtures.bodydictionary.DictionaryImpl.java Source code

Introduction

Here is the source code for fixtures.bodydictionary.DictionaryImpl.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 0.12.0.0
 * Changes may cause incorrect behavior and will be lost if the code is
 * regenerated.
 */

package fixtures.bodydictionary;

import com.google.common.reflect.TypeToken;
import com.microsoft.rest.ServiceCallback;
import com.microsoft.rest.ServiceException;
import com.microsoft.rest.ServiceResponse;
import com.microsoft.rest.ServiceResponseBuilder;
import com.microsoft.rest.ServiceResponseCallback;
import com.microsoft.rest.ServiceResponseEmptyCallback;
import com.squareup.okhttp.ResponseBody;
import retrofit.Retrofit;
import retrofit.Call;
import retrofit.Response;
import java.util.Map;
import fixtures.bodydictionary.models.Error;
import org.joda.time.LocalDate;
import org.joda.time.DateTime;
import com.microsoft.rest.DateTimeRfc1123;
import org.joda.time.Period;
import org.apache.commons.codec.binary.Base64;
import fixtures.bodydictionary.models.Widget;
import java.util.List;
import com.microsoft.rest.Validator;

public class DictionaryImpl implements Dictionary {
    private DictionaryService service;
    AutoRestSwaggerBATdictionaryService client;

    public DictionaryImpl(Retrofit retrofit, AutoRestSwaggerBATdictionaryService client) {
        this.service = retrofit.create(DictionaryService.class);
        this.client = client;
    }

    /**
     * Get null dictionary value
     *
     * @return the Map<String, Integer> object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Integer> getNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getNull();
            ServiceResponse<Map<String, Integer>> response = getNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get null dictionary value
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getNullAsync(final ServiceCallback<Map<String, Integer>> serviceCallback) {
        Call<ResponseBody> call = service.getNull();
        call.enqueue(new ServiceResponseCallback<Map<String, Integer>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Integer>> getNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Integer>>()
                .register(200, new TypeToken<Map<String, Integer>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get empty dictionary value {}
     *
     * @return the Map&lt;String, Integer&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Integer> getEmpty() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getEmpty();
            ServiceResponse<Map<String, Integer>> response = getEmptyDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get empty dictionary value {}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getEmptyAsync(final ServiceCallback<Map<String, Integer>> serviceCallback) {
        Call<ResponseBody> call = service.getEmpty();
        call.enqueue(new ServiceResponseCallback<Map<String, Integer>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getEmptyDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Integer>> getEmptyDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Integer>>()
                .register(200, new TypeToken<Map<String, Integer>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Set dictionary value empty {}
     *
     * @param arrayBody the Map&lt;String, String&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putEmpty(Map<String, String> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putEmpty(arrayBody);
            ServiceResponse<Void> response = putEmptyDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Set dictionary value empty {}
     *
     * @param arrayBody the Map&lt;String, String&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putEmptyAsync(Map<String, String> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putEmpty(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putEmptyDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putEmptyDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get Dictionary with null value
     *
     * @return the Map&lt;String, String&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, String> getNullValue() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getNullValue();
            ServiceResponse<Map<String, String>> response = getNullValueDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get Dictionary with null value
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getNullValueAsync(final ServiceCallback<Map<String, String>> serviceCallback) {
        Call<ResponseBody> call = service.getNullValue();
        call.enqueue(new ServiceResponseCallback<Map<String, String>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getNullValueDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, String>> getNullValueDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, String>>()
                .register(200, new TypeToken<Map<String, String>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get Dictionary with null key
     *
     * @return the Map&lt;String, String&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, String> getNullKey() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getNullKey();
            ServiceResponse<Map<String, String>> response = getNullKeyDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get Dictionary with null key
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getNullKeyAsync(final ServiceCallback<Map<String, String>> serviceCallback) {
        Call<ResponseBody> call = service.getNullKey();
        call.enqueue(new ServiceResponseCallback<Map<String, String>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getNullKeyDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, String>> getNullKeyDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, String>>()
                .register(200, new TypeToken<Map<String, String>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get Dictionary with key as empty string
     *
     * @return the Map&lt;String, String&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, String> getEmptyStringKey() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getEmptyStringKey();
            ServiceResponse<Map<String, String>> response = getEmptyStringKeyDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get Dictionary with key as empty string
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getEmptyStringKeyAsync(final ServiceCallback<Map<String, String>> serviceCallback) {
        Call<ResponseBody> call = service.getEmptyStringKey();
        call.enqueue(new ServiceResponseCallback<Map<String, String>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getEmptyStringKeyDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, String>> getEmptyStringKeyDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, String>>()
                .register(200, new TypeToken<Map<String, String>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get invalid Dictionary value
     *
     * @return the Map&lt;String, String&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, String> getInvalid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getInvalid();
            ServiceResponse<Map<String, String>> response = getInvalidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get invalid Dictionary value
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getInvalidAsync(final ServiceCallback<Map<String, String>> serviceCallback) {
        Call<ResponseBody> call = service.getInvalid();
        call.enqueue(new ServiceResponseCallback<Map<String, String>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getInvalidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, String>> getInvalidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, String>>()
                .register(200, new TypeToken<Map<String, String>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get boolean dictionary value {"0": true, "1": false, "2": false, "3": true }
     *
     * @return the Map&lt;String, Boolean&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Boolean> getBooleanTfft() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getBooleanTfft();
            ServiceResponse<Map<String, Boolean>> response = getBooleanTfftDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get boolean dictionary value {"0": true, "1": false, "2": false, "3": true }
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getBooleanTfftAsync(final ServiceCallback<Map<String, Boolean>> serviceCallback) {
        Call<ResponseBody> call = service.getBooleanTfft();
        call.enqueue(new ServiceResponseCallback<Map<String, Boolean>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getBooleanTfftDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Boolean>> getBooleanTfftDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Boolean>>()
                .register(200, new TypeToken<Map<String, Boolean>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Set dictionary value empty {"0": true, "1": false, "2": false, "3": true }
     *
     * @param arrayBody the Map&lt;String, Boolean&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putBooleanTfft(Map<String, Boolean> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putBooleanTfft(arrayBody);
            ServiceResponse<Void> response = putBooleanTfftDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Set dictionary value empty {"0": true, "1": false, "2": false, "3": true }
     *
     * @param arrayBody the Map&lt;String, Boolean&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putBooleanTfftAsync(Map<String, Boolean> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putBooleanTfft(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putBooleanTfftDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putBooleanTfftDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get boolean dictionary value {"0": true, "1": null, "2": false }
     *
     * @return the Map&lt;String, Boolean&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Boolean> getBooleanInvalidNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getBooleanInvalidNull();
            ServiceResponse<Map<String, Boolean>> response = getBooleanInvalidNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get boolean dictionary value {"0": true, "1": null, "2": false }
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getBooleanInvalidNullAsync(
            final ServiceCallback<Map<String, Boolean>> serviceCallback) {
        Call<ResponseBody> call = service.getBooleanInvalidNull();
        call.enqueue(new ServiceResponseCallback<Map<String, Boolean>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getBooleanInvalidNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Boolean>> getBooleanInvalidNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Boolean>>()
                .register(200, new TypeToken<Map<String, Boolean>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get boolean dictionary value '{"0": true, "1": "boolean", "2": false}'
     *
     * @return the Map&lt;String, Boolean&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Boolean> getBooleanInvalidString() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getBooleanInvalidString();
            ServiceResponse<Map<String, Boolean>> response = getBooleanInvalidStringDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get boolean dictionary value '{"0": true, "1": "boolean", "2": false}'
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getBooleanInvalidStringAsync(
            final ServiceCallback<Map<String, Boolean>> serviceCallback) {
        Call<ResponseBody> call = service.getBooleanInvalidString();
        call.enqueue(new ServiceResponseCallback<Map<String, Boolean>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getBooleanInvalidStringDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Boolean>> getBooleanInvalidStringDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Boolean>>()
                .register(200, new TypeToken<Map<String, Boolean>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get integer dictionary value {"0": 1, "1": -1, "2": 3, "3": 300}
     *
     * @return the Map&lt;String, Integer&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Integer> getIntegerValid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getIntegerValid();
            ServiceResponse<Map<String, Integer>> response = getIntegerValidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get integer dictionary value {"0": 1, "1": -1, "2": 3, "3": 300}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getIntegerValidAsync(final ServiceCallback<Map<String, Integer>> serviceCallback) {
        Call<ResponseBody> call = service.getIntegerValid();
        call.enqueue(new ServiceResponseCallback<Map<String, Integer>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getIntegerValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Integer>> getIntegerValidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Integer>>()
                .register(200, new TypeToken<Map<String, Integer>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Set dictionary value empty {"0": 1, "1": -1, "2": 3, "3": 300}
     *
     * @param arrayBody the Map&lt;String, Integer&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putIntegerValid(Map<String, Integer> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putIntegerValid(arrayBody);
            ServiceResponse<Void> response = putIntegerValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Set dictionary value empty {"0": 1, "1": -1, "2": 3, "3": 300}
     *
     * @param arrayBody the Map&lt;String, Integer&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putIntegerValidAsync(Map<String, Integer> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putIntegerValid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putIntegerValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putIntegerValidDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get integer dictionary value {"0": 1, "1": null, "2": 0}
     *
     * @return the Map&lt;String, Integer&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Integer> getIntInvalidNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getIntInvalidNull();
            ServiceResponse<Map<String, Integer>> response = getIntInvalidNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get integer dictionary value {"0": 1, "1": null, "2": 0}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getIntInvalidNullAsync(final ServiceCallback<Map<String, Integer>> serviceCallback) {
        Call<ResponseBody> call = service.getIntInvalidNull();
        call.enqueue(new ServiceResponseCallback<Map<String, Integer>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getIntInvalidNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Integer>> getIntInvalidNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Integer>>()
                .register(200, new TypeToken<Map<String, Integer>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get integer dictionary value {"0": 1, "1": "integer", "2": 0}
     *
     * @return the Map&lt;String, Integer&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Integer> getIntInvalidString() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getIntInvalidString();
            ServiceResponse<Map<String, Integer>> response = getIntInvalidStringDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get integer dictionary value {"0": 1, "1": "integer", "2": 0}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getIntInvalidStringAsync(
            final ServiceCallback<Map<String, Integer>> serviceCallback) {
        Call<ResponseBody> call = service.getIntInvalidString();
        call.enqueue(new ServiceResponseCallback<Map<String, Integer>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getIntInvalidStringDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Integer>> getIntInvalidStringDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Integer>>()
                .register(200, new TypeToken<Map<String, Integer>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get integer dictionary value {"0": 1, "1": -1, "2": 3, "3": 300}
     *
     * @return the Map&lt;String, Long&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Long> getLongValid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getLongValid();
            ServiceResponse<Map<String, Long>> response = getLongValidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get integer dictionary value {"0": 1, "1": -1, "2": 3, "3": 300}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getLongValidAsync(final ServiceCallback<Map<String, Long>> serviceCallback) {
        Call<ResponseBody> call = service.getLongValid();
        call.enqueue(new ServiceResponseCallback<Map<String, Long>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getLongValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Long>> getLongValidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Long>>().register(200, new TypeToken<Map<String, Long>>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Set dictionary value empty {"0": 1, "1": -1, "2": 3, "3": 300}
     *
     * @param arrayBody the Map&lt;String, Long&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putLongValid(Map<String, Long> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putLongValid(arrayBody);
            ServiceResponse<Void> response = putLongValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Set dictionary value empty {"0": 1, "1": -1, "2": 3, "3": 300}
     *
     * @param arrayBody the Map&lt;String, Long&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putLongValidAsync(Map<String, Long> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putLongValid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putLongValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putLongValidDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get long dictionary value {"0": 1, "1": null, "2": 0}
     *
     * @return the Map&lt;String, Long&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Long> getLongInvalidNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getLongInvalidNull();
            ServiceResponse<Map<String, Long>> response = getLongInvalidNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get long dictionary value {"0": 1, "1": null, "2": 0}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getLongInvalidNullAsync(final ServiceCallback<Map<String, Long>> serviceCallback) {
        Call<ResponseBody> call = service.getLongInvalidNull();
        call.enqueue(new ServiceResponseCallback<Map<String, Long>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getLongInvalidNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Long>> getLongInvalidNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Long>>().register(200, new TypeToken<Map<String, Long>>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get long dictionary value {"0": 1, "1": "integer", "2": 0}
     *
     * @return the Map&lt;String, Long&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Long> getLongInvalidString() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getLongInvalidString();
            ServiceResponse<Map<String, Long>> response = getLongInvalidStringDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get long dictionary value {"0": 1, "1": "integer", "2": 0}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getLongInvalidStringAsync(final ServiceCallback<Map<String, Long>> serviceCallback) {
        Call<ResponseBody> call = service.getLongInvalidString();
        call.enqueue(new ServiceResponseCallback<Map<String, Long>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getLongInvalidStringDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Long>> getLongInvalidStringDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Long>>().register(200, new TypeToken<Map<String, Long>>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get float dictionary value {"0": 0, "1": -0.01, "2": 1.2e20}
     *
     * @return the Map&lt;String, Double&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Double> getFloatValid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getFloatValid();
            ServiceResponse<Map<String, Double>> response = getFloatValidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get float dictionary value {"0": 0, "1": -0.01, "2": 1.2e20}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getFloatValidAsync(final ServiceCallback<Map<String, Double>> serviceCallback) {
        Call<ResponseBody> call = service.getFloatValid();
        call.enqueue(new ServiceResponseCallback<Map<String, Double>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getFloatValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Double>> getFloatValidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Double>>()
                .register(200, new TypeToken<Map<String, Double>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Set dictionary value {"0": 0, "1": -0.01, "2": 1.2e20}
     *
     * @param arrayBody the Map&lt;String, Double&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putFloatValid(Map<String, Double> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putFloatValid(arrayBody);
            ServiceResponse<Void> response = putFloatValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Set dictionary value {"0": 0, "1": -0.01, "2": 1.2e20}
     *
     * @param arrayBody the Map&lt;String, Double&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putFloatValidAsync(Map<String, Double> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putFloatValid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putFloatValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putFloatValidDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get float dictionary value {"0": 0.0, "1": null, "2": 1.2e20}
     *
     * @return the Map&lt;String, Double&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Double> getFloatInvalidNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getFloatInvalidNull();
            ServiceResponse<Map<String, Double>> response = getFloatInvalidNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get float dictionary value {"0": 0.0, "1": null, "2": 1.2e20}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getFloatInvalidNullAsync(final ServiceCallback<Map<String, Double>> serviceCallback) {
        Call<ResponseBody> call = service.getFloatInvalidNull();
        call.enqueue(new ServiceResponseCallback<Map<String, Double>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getFloatInvalidNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Double>> getFloatInvalidNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Double>>()
                .register(200, new TypeToken<Map<String, Double>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get boolean dictionary value {"0": 1.0, "1": "number", "2": 0.0}
     *
     * @return the Map&lt;String, Double&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Double> getFloatInvalidString() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getFloatInvalidString();
            ServiceResponse<Map<String, Double>> response = getFloatInvalidStringDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get boolean dictionary value {"0": 1.0, "1": "number", "2": 0.0}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getFloatInvalidStringAsync(
            final ServiceCallback<Map<String, Double>> serviceCallback) {
        Call<ResponseBody> call = service.getFloatInvalidString();
        call.enqueue(new ServiceResponseCallback<Map<String, Double>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getFloatInvalidStringDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Double>> getFloatInvalidStringDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Double>>()
                .register(200, new TypeToken<Map<String, Double>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get float dictionary value {"0": 0, "1": -0.01, "2": 1.2e20}
     *
     * @return the Map&lt;String, Double&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Double> getDoubleValid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDoubleValid();
            ServiceResponse<Map<String, Double>> response = getDoubleValidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get float dictionary value {"0": 0, "1": -0.01, "2": 1.2e20}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDoubleValidAsync(final ServiceCallback<Map<String, Double>> serviceCallback) {
        Call<ResponseBody> call = service.getDoubleValid();
        call.enqueue(new ServiceResponseCallback<Map<String, Double>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDoubleValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Double>> getDoubleValidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Double>>()
                .register(200, new TypeToken<Map<String, Double>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Set dictionary value {"0": 0, "1": -0.01, "2": 1.2e20}
     *
     * @param arrayBody the Map&lt;String, Double&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putDoubleValid(Map<String, Double> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putDoubleValid(arrayBody);
            ServiceResponse<Void> response = putDoubleValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Set dictionary value {"0": 0, "1": -0.01, "2": 1.2e20}
     *
     * @param arrayBody the Map&lt;String, Double&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putDoubleValidAsync(Map<String, Double> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putDoubleValid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putDoubleValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putDoubleValidDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get float dictionary value {"0": 0.0, "1": null, "2": 1.2e20}
     *
     * @return the Map&lt;String, Double&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Double> getDoubleInvalidNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDoubleInvalidNull();
            ServiceResponse<Map<String, Double>> response = getDoubleInvalidNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get float dictionary value {"0": 0.0, "1": null, "2": 1.2e20}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDoubleInvalidNullAsync(
            final ServiceCallback<Map<String, Double>> serviceCallback) {
        Call<ResponseBody> call = service.getDoubleInvalidNull();
        call.enqueue(new ServiceResponseCallback<Map<String, Double>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDoubleInvalidNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Double>> getDoubleInvalidNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Double>>()
                .register(200, new TypeToken<Map<String, Double>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get boolean dictionary value {"0": 1.0, "1": "number", "2": 0.0}
     *
     * @return the Map&lt;String, Double&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Double> getDoubleInvalidString() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDoubleInvalidString();
            ServiceResponse<Map<String, Double>> response = getDoubleInvalidStringDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get boolean dictionary value {"0": 1.0, "1": "number", "2": 0.0}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDoubleInvalidStringAsync(
            final ServiceCallback<Map<String, Double>> serviceCallback) {
        Call<ResponseBody> call = service.getDoubleInvalidString();
        call.enqueue(new ServiceResponseCallback<Map<String, Double>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDoubleInvalidStringDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Double>> getDoubleInvalidStringDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Double>>()
                .register(200, new TypeToken<Map<String, Double>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get string dictionary value {"0": "foo1", "1": "foo2", "2": "foo3"}
     *
     * @return the Map&lt;String, String&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, String> getStringValid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getStringValid();
            ServiceResponse<Map<String, String>> response = getStringValidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get string dictionary value {"0": "foo1", "1": "foo2", "2": "foo3"}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getStringValidAsync(final ServiceCallback<Map<String, String>> serviceCallback) {
        Call<ResponseBody> call = service.getStringValid();
        call.enqueue(new ServiceResponseCallback<Map<String, String>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getStringValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, String>> getStringValidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, String>>()
                .register(200, new TypeToken<Map<String, String>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Set dictionary value {"0": "foo1", "1": "foo2", "2": "foo3"}
     *
     * @param arrayBody the Map&lt;String, String&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putStringValid(Map<String, String> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putStringValid(arrayBody);
            ServiceResponse<Void> response = putStringValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Set dictionary value {"0": "foo1", "1": "foo2", "2": "foo3"}
     *
     * @param arrayBody the Map&lt;String, String&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putStringValidAsync(Map<String, String> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putStringValid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putStringValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putStringValidDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get string dictionary value {"0": "foo", "1": null, "2": "foo2"}
     *
     * @return the Map&lt;String, String&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, String> getStringWithNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getStringWithNull();
            ServiceResponse<Map<String, String>> response = getStringWithNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get string dictionary value {"0": "foo", "1": null, "2": "foo2"}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getStringWithNullAsync(final ServiceCallback<Map<String, String>> serviceCallback) {
        Call<ResponseBody> call = service.getStringWithNull();
        call.enqueue(new ServiceResponseCallback<Map<String, String>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getStringWithNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, String>> getStringWithNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, String>>()
                .register(200, new TypeToken<Map<String, String>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get string dictionary value {"0": "foo", "1": 123, "2": "foo2"}
     *
     * @return the Map&lt;String, String&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, String> getStringWithInvalid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getStringWithInvalid();
            ServiceResponse<Map<String, String>> response = getStringWithInvalidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get string dictionary value {"0": "foo", "1": 123, "2": "foo2"}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getStringWithInvalidAsync(
            final ServiceCallback<Map<String, String>> serviceCallback) {
        Call<ResponseBody> call = service.getStringWithInvalid();
        call.enqueue(new ServiceResponseCallback<Map<String, String>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getStringWithInvalidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, String>> getStringWithInvalidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, String>>()
                .register(200, new TypeToken<Map<String, String>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get integer dictionary value {"0": "2000-12-01", "1": "1980-01-02", "2": "1492-10-12"}
     *
     * @return the Map&lt;String, LocalDate&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, LocalDate> getDateValid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDateValid();
            ServiceResponse<Map<String, LocalDate>> response = getDateValidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get integer dictionary value {"0": "2000-12-01", "1": "1980-01-02", "2": "1492-10-12"}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDateValidAsync(final ServiceCallback<Map<String, LocalDate>> serviceCallback) {
        Call<ResponseBody> call = service.getDateValid();
        call.enqueue(new ServiceResponseCallback<Map<String, LocalDate>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDateValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, LocalDate>> getDateValidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, LocalDate>>()
                .register(200, new TypeToken<Map<String, LocalDate>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Set dictionary value  {"0": "2000-12-01", "1": "1980-01-02", "2": "1492-10-12"}
     *
     * @param arrayBody the Map&lt;String, LocalDate&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putDateValid(Map<String, LocalDate> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putDateValid(arrayBody);
            ServiceResponse<Void> response = putDateValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Set dictionary value  {"0": "2000-12-01", "1": "1980-01-02", "2": "1492-10-12"}
     *
     * @param arrayBody the Map&lt;String, LocalDate&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putDateValidAsync(Map<String, LocalDate> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putDateValid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putDateValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putDateValidDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get date dictionary value {"0": "2012-01-01", "1": null, "2": "1776-07-04"}
     *
     * @return the Map&lt;String, LocalDate&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, LocalDate> getDateInvalidNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDateInvalidNull();
            ServiceResponse<Map<String, LocalDate>> response = getDateInvalidNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get date dictionary value {"0": "2012-01-01", "1": null, "2": "1776-07-04"}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDateInvalidNullAsync(
            final ServiceCallback<Map<String, LocalDate>> serviceCallback) {
        Call<ResponseBody> call = service.getDateInvalidNull();
        call.enqueue(new ServiceResponseCallback<Map<String, LocalDate>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDateInvalidNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, LocalDate>> getDateInvalidNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, LocalDate>>()
                .register(200, new TypeToken<Map<String, LocalDate>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get date dictionary value {"0": "2011-03-22", "1": "date"}
     *
     * @return the Map&lt;String, LocalDate&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, LocalDate> getDateInvalidChars() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDateInvalidChars();
            ServiceResponse<Map<String, LocalDate>> response = getDateInvalidCharsDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get date dictionary value {"0": "2011-03-22", "1": "date"}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDateInvalidCharsAsync(
            final ServiceCallback<Map<String, LocalDate>> serviceCallback) {
        Call<ResponseBody> call = service.getDateInvalidChars();
        call.enqueue(new ServiceResponseCallback<Map<String, LocalDate>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDateInvalidCharsDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, LocalDate>> getDateInvalidCharsDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, LocalDate>>()
                .register(200, new TypeToken<Map<String, LocalDate>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get date-time dictionary value {"0": "2000-12-01t00:00:01z", "1": "1980-01-02T00:11:35+01:00", "2": "1492-10-12T10:15:01-08:00"}
     *
     * @return the Map&lt;String, DateTime&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, DateTime> getDateTimeValid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDateTimeValid();
            ServiceResponse<Map<String, DateTime>> response = getDateTimeValidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get date-time dictionary value {"0": "2000-12-01t00:00:01z", "1": "1980-01-02T00:11:35+01:00", "2": "1492-10-12T10:15:01-08:00"}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDateTimeValidAsync(final ServiceCallback<Map<String, DateTime>> serviceCallback) {
        Call<ResponseBody> call = service.getDateTimeValid();
        call.enqueue(new ServiceResponseCallback<Map<String, DateTime>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDateTimeValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, DateTime>> getDateTimeValidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, DateTime>>()
                .register(200, new TypeToken<Map<String, DateTime>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Set dictionary value  {"0": "2000-12-01t00:00:01z", "1": "1980-01-02T00:11:35+01:00", "2": "1492-10-12T10:15:01-08:00"}
     *
     * @param arrayBody the Map&lt;String, DateTime&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putDateTimeValid(Map<String, DateTime> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putDateTimeValid(arrayBody);
            ServiceResponse<Void> response = putDateTimeValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Set dictionary value  {"0": "2000-12-01t00:00:01z", "1": "1980-01-02T00:11:35+01:00", "2": "1492-10-12T10:15:01-08:00"}
     *
     * @param arrayBody the Map&lt;String, DateTime&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putDateTimeValidAsync(Map<String, DateTime> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putDateTimeValid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putDateTimeValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putDateTimeValidDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get date dictionary value {"0": "2000-12-01t00:00:01z", "1": null}
     *
     * @return the Map&lt;String, DateTime&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, DateTime> getDateTimeInvalidNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDateTimeInvalidNull();
            ServiceResponse<Map<String, DateTime>> response = getDateTimeInvalidNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get date dictionary value {"0": "2000-12-01t00:00:01z", "1": null}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDateTimeInvalidNullAsync(
            final ServiceCallback<Map<String, DateTime>> serviceCallback) {
        Call<ResponseBody> call = service.getDateTimeInvalidNull();
        call.enqueue(new ServiceResponseCallback<Map<String, DateTime>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDateTimeInvalidNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, DateTime>> getDateTimeInvalidNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, DateTime>>()
                .register(200, new TypeToken<Map<String, DateTime>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get date dictionary value {"0": "2000-12-01t00:00:01z", "1": "date-time"}
     *
     * @return the Map&lt;String, DateTime&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, DateTime> getDateTimeInvalidChars() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDateTimeInvalidChars();
            ServiceResponse<Map<String, DateTime>> response = getDateTimeInvalidCharsDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get date dictionary value {"0": "2000-12-01t00:00:01z", "1": "date-time"}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDateTimeInvalidCharsAsync(
            final ServiceCallback<Map<String, DateTime>> serviceCallback) {
        Call<ResponseBody> call = service.getDateTimeInvalidChars();
        call.enqueue(new ServiceResponseCallback<Map<String, DateTime>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDateTimeInvalidCharsDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, DateTime>> getDateTimeInvalidCharsDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, DateTime>>()
                .register(200, new TypeToken<Map<String, DateTime>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get date-time-rfc1123 dictionary value {"0": "Fri, 01 Dec 2000 00:00:01 GMT", "1": "Wed, 02 Jan 1980 00:11:35 GMT", "2": "Wed, 12 Oct 1492 10:15:01 GMT"}
     *
     * @return the Map&lt;String, DateTimeRfc1123&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, DateTimeRfc1123> getDateTimeRfc1123Valid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDateTimeRfc1123Valid();
            ServiceResponse<Map<String, DateTimeRfc1123>> response = getDateTimeRfc1123ValidDelegate(call.execute(),
                    null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get date-time-rfc1123 dictionary value {"0": "Fri, 01 Dec 2000 00:00:01 GMT", "1": "Wed, 02 Jan 1980 00:11:35 GMT", "2": "Wed, 12 Oct 1492 10:15:01 GMT"}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDateTimeRfc1123ValidAsync(
            final ServiceCallback<Map<String, DateTimeRfc1123>> serviceCallback) {
        Call<ResponseBody> call = service.getDateTimeRfc1123Valid();
        call.enqueue(new ServiceResponseCallback<Map<String, DateTimeRfc1123>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDateTimeRfc1123ValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, DateTimeRfc1123>> getDateTimeRfc1123ValidDelegate(
            Response<ResponseBody> response, Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, DateTimeRfc1123>>()
                .register(200, new TypeToken<Map<String, DateTimeRfc1123>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Set dictionary value empty {"0": "Fri, 01 Dec 2000 00:00:01 GMT", "1": "Wed, 02 Jan 1980 00:11:35 GMT", "2": "Wed, 12 Oct 1492 10:15:01 GMT"}
     *
     * @param arrayBody the Map&lt;String, DateTimeRfc1123&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putDateTimeRfc1123Valid(Map<String, DateTimeRfc1123> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putDateTimeRfc1123Valid(arrayBody);
            ServiceResponse<Void> response = putDateTimeRfc1123ValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Set dictionary value empty {"0": "Fri, 01 Dec 2000 00:00:01 GMT", "1": "Wed, 02 Jan 1980 00:11:35 GMT", "2": "Wed, 12 Oct 1492 10:15:01 GMT"}
     *
     * @param arrayBody the Map&lt;String, DateTimeRfc1123&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putDateTimeRfc1123ValidAsync(Map<String, DateTimeRfc1123> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putDateTimeRfc1123Valid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putDateTimeRfc1123ValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putDateTimeRfc1123ValidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get duration dictionary value {"0": "P123DT22H14M12.011S", "1": "P5DT1H0M0S"}
     *
     * @return the Map&lt;String, Period&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Period> getDurationValid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDurationValid();
            ServiceResponse<Map<String, Period>> response = getDurationValidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get duration dictionary value {"0": "P123DT22H14M12.011S", "1": "P5DT1H0M0S"}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDurationValidAsync(final ServiceCallback<Map<String, Period>> serviceCallback) {
        Call<ResponseBody> call = service.getDurationValid();
        call.enqueue(new ServiceResponseCallback<Map<String, Period>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDurationValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Period>> getDurationValidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Period>>()
                .register(200, new TypeToken<Map<String, Period>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Set dictionary value  {"0": "P123DT22H14M12.011S", "1": "P5DT1H0M0S"}
     *
     * @param arrayBody the Map&lt;String, Period&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putDurationValid(Map<String, Period> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putDurationValid(arrayBody);
            ServiceResponse<Void> response = putDurationValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Set dictionary value  {"0": "P123DT22H14M12.011S", "1": "P5DT1H0M0S"}
     *
     * @param arrayBody the Map&lt;String, Period&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putDurationValidAsync(Map<String, Period> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putDurationValid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putDurationValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putDurationValidDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get byte dictionary value {"0": hex(FF FF FF FA), "1": hex(01 02 03), "2": hex (25, 29, 43)} with each item encoded in base64
     *
     * @return the Map&lt;String, byte[]&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, byte[]> getByteValid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getByteValid();
            ServiceResponse<Map<String, byte[]>> response = getByteValidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get byte dictionary value {"0": hex(FF FF FF FA), "1": hex(01 02 03), "2": hex (25, 29, 43)} with each item encoded in base64
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getByteValidAsync(final ServiceCallback<Map<String, byte[]>> serviceCallback) {
        Call<ResponseBody> call = service.getByteValid();
        call.enqueue(new ServiceResponseCallback<Map<String, byte[]>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getByteValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, byte[]>> getByteValidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, byte[]>>()
                .register(200, new TypeToken<Map<String, byte[]>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Put the dictionary value {"0": hex(FF FF FF FA), "1": hex(01 02 03), "2": hex (25, 29, 43)} with each elementencoded in base 64
     *
     * @param arrayBody the Map&lt;String, byte[]&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putByteValid(Map<String, byte[]> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putByteValid(arrayBody);
            ServiceResponse<Void> response = putByteValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Put the dictionary value {"0": hex(FF FF FF FA), "1": hex(01 02 03), "2": hex (25, 29, 43)} with each elementencoded in base 64
     *
     * @param arrayBody the Map&lt;String, byte[]&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putByteValidAsync(Map<String, byte[]> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putByteValid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putByteValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putByteValidDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get byte dictionary value {"0": hex(FF FF FF FA), "1": null} with the first item base64 encoded
     *
     * @return the Map&lt;String, byte[]&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, byte[]> getByteInvalidNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getByteInvalidNull();
            ServiceResponse<Map<String, byte[]>> response = getByteInvalidNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get byte dictionary value {"0": hex(FF FF FF FA), "1": null} with the first item base64 encoded
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getByteInvalidNullAsync(final ServiceCallback<Map<String, byte[]>> serviceCallback) {
        Call<ResponseBody> call = service.getByteInvalidNull();
        call.enqueue(new ServiceResponseCallback<Map<String, byte[]>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getByteInvalidNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, byte[]>> getByteInvalidNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, byte[]>>()
                .register(200, new TypeToken<Map<String, byte[]>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get dictionary of complex type null value
     *
     * @return the Map&lt;String, Widget&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Widget> getComplexNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getComplexNull();
            ServiceResponse<Map<String, Widget>> response = getComplexNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get dictionary of complex type null value
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getComplexNullAsync(final ServiceCallback<Map<String, Widget>> serviceCallback) {
        Call<ResponseBody> call = service.getComplexNull();
        call.enqueue(new ServiceResponseCallback<Map<String, Widget>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getComplexNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Widget>> getComplexNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Widget>>()
                .register(200, new TypeToken<Map<String, Widget>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get empty dictionary of complex type {}
     *
     * @return the Map&lt;String, Widget&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Widget> getComplexEmpty() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getComplexEmpty();
            ServiceResponse<Map<String, Widget>> response = getComplexEmptyDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get empty dictionary of complex type {}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getComplexEmptyAsync(final ServiceCallback<Map<String, Widget>> serviceCallback) {
        Call<ResponseBody> call = service.getComplexEmpty();
        call.enqueue(new ServiceResponseCallback<Map<String, Widget>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getComplexEmptyDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Widget>> getComplexEmptyDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Widget>>()
                .register(200, new TypeToken<Map<String, Widget>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get dictionary of complex type with null item {"0": {"integer": 1, "string": "2"}, "1": null, "2": {"integer": 5, "string": "6"}}
     *
     * @return the Map&lt;String, Widget&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Widget> getComplexItemNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getComplexItemNull();
            ServiceResponse<Map<String, Widget>> response = getComplexItemNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get dictionary of complex type with null item {"0": {"integer": 1, "string": "2"}, "1": null, "2": {"integer": 5, "string": "6"}}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getComplexItemNullAsync(final ServiceCallback<Map<String, Widget>> serviceCallback) {
        Call<ResponseBody> call = service.getComplexItemNull();
        call.enqueue(new ServiceResponseCallback<Map<String, Widget>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getComplexItemNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Widget>> getComplexItemNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Widget>>()
                .register(200, new TypeToken<Map<String, Widget>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get dictionary of complex type with empty item {"0": {"integer": 1, "string": "2"}, "1:" {}, "2": {"integer": 5, "string": "6"}}
     *
     * @return the Map&lt;String, Widget&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Widget> getComplexItemEmpty() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getComplexItemEmpty();
            ServiceResponse<Map<String, Widget>> response = getComplexItemEmptyDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get dictionary of complex type with empty item {"0": {"integer": 1, "string": "2"}, "1:" {}, "2": {"integer": 5, "string": "6"}}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getComplexItemEmptyAsync(final ServiceCallback<Map<String, Widget>> serviceCallback) {
        Call<ResponseBody> call = service.getComplexItemEmpty();
        call.enqueue(new ServiceResponseCallback<Map<String, Widget>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getComplexItemEmptyDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Widget>> getComplexItemEmptyDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Widget>>()
                .register(200, new TypeToken<Map<String, Widget>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get dictionary of complex type with {"0": {"integer": 1, "string": "2"}, "1": {"integer": 3, "string": "4"}, "2": {"integer": 5, "string": "6"}}
     *
     * @return the Map&lt;String, Widget&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Widget> getComplexValid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getComplexValid();
            ServiceResponse<Map<String, Widget>> response = getComplexValidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get dictionary of complex type with {"0": {"integer": 1, "string": "2"}, "1": {"integer": 3, "string": "4"}, "2": {"integer": 5, "string": "6"}}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getComplexValidAsync(final ServiceCallback<Map<String, Widget>> serviceCallback) {
        Call<ResponseBody> call = service.getComplexValid();
        call.enqueue(new ServiceResponseCallback<Map<String, Widget>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getComplexValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Widget>> getComplexValidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Widget>>()
                .register(200, new TypeToken<Map<String, Widget>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Put an dictionary of complex type with values {"0": {"integer": 1, "string": "2"}, "1": {"integer": 3, "string": "4"}, "2": {"integer": 5, "string": "6"}}
     *
     * @param arrayBody the Map&lt;String, Widget&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putComplexValid(Map<String, Widget> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putComplexValid(arrayBody);
            ServiceResponse<Void> response = putComplexValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Put an dictionary of complex type with values {"0": {"integer": 1, "string": "2"}, "1": {"integer": 3, "string": "4"}, "2": {"integer": 5, "string": "6"}}
     *
     * @param arrayBody the Map&lt;String, Widget&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putComplexValidAsync(Map<String, Widget> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putComplexValid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putComplexValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putComplexValidDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get a null array
     *
     * @return the Map&lt;String, List&lt;String&gt;&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, List<String>> getArrayNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getArrayNull();
            ServiceResponse<Map<String, List<String>>> response = getArrayNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get a null array
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getArrayNullAsync(final ServiceCallback<Map<String, List<String>>> serviceCallback) {
        Call<ResponseBody> call = service.getArrayNull();
        call.enqueue(new ServiceResponseCallback<Map<String, List<String>>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getArrayNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, List<String>>> getArrayNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, List<String>>>()
                .register(200, new TypeToken<Map<String, List<String>>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get an empty dictionary {}
     *
     * @return the Map&lt;String, List&lt;String&gt;&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, List<String>> getArrayEmpty() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getArrayEmpty();
            ServiceResponse<Map<String, List<String>>> response = getArrayEmptyDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get an empty dictionary {}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getArrayEmptyAsync(final ServiceCallback<Map<String, List<String>>> serviceCallback) {
        Call<ResponseBody> call = service.getArrayEmpty();
        call.enqueue(new ServiceResponseCallback<Map<String, List<String>>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getArrayEmptyDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, List<String>>> getArrayEmptyDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, List<String>>>()
                .register(200, new TypeToken<Map<String, List<String>>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get an dictionary of array of strings {"0": ["1", "2", "3"], "1": null, "2": ["7", "8", "9"]}
     *
     * @return the Map&lt;String, List&lt;String&gt;&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, List<String>> getArrayItemNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getArrayItemNull();
            ServiceResponse<Map<String, List<String>>> response = getArrayItemNullDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get an dictionary of array of strings {"0": ["1", "2", "3"], "1": null, "2": ["7", "8", "9"]}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getArrayItemNullAsync(
            final ServiceCallback<Map<String, List<String>>> serviceCallback) {
        Call<ResponseBody> call = service.getArrayItemNull();
        call.enqueue(new ServiceResponseCallback<Map<String, List<String>>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getArrayItemNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, List<String>>> getArrayItemNullDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, List<String>>>()
                .register(200, new TypeToken<Map<String, List<String>>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get an array of array of strings [{"0": ["1", "2", "3"], "1": [], "2": ["7", "8", "9"]}
     *
     * @return the Map&lt;String, List&lt;String&gt;&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, List<String>> getArrayItemEmpty() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getArrayItemEmpty();
            ServiceResponse<Map<String, List<String>>> response = getArrayItemEmptyDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get an array of array of strings [{"0": ["1", "2", "3"], "1": [], "2": ["7", "8", "9"]}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getArrayItemEmptyAsync(
            final ServiceCallback<Map<String, List<String>>> serviceCallback) {
        Call<ResponseBody> call = service.getArrayItemEmpty();
        call.enqueue(new ServiceResponseCallback<Map<String, List<String>>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getArrayItemEmptyDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, List<String>>> getArrayItemEmptyDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, List<String>>>()
                .register(200, new TypeToken<Map<String, List<String>>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get an array of array of strings {"0": ["1", "2", "3"], "1": ["4", "5", "6"], "2": ["7", "8", "9"]}
     *
     * @return the Map&lt;String, List&lt;String&gt;&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, List<String>> getArrayValid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getArrayValid();
            ServiceResponse<Map<String, List<String>>> response = getArrayValidDelegate(call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get an array of array of strings {"0": ["1", "2", "3"], "1": ["4", "5", "6"], "2": ["7", "8", "9"]}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getArrayValidAsync(final ServiceCallback<Map<String, List<String>>> serviceCallback) {
        Call<ResponseBody> call = service.getArrayValid();
        call.enqueue(new ServiceResponseCallback<Map<String, List<String>>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getArrayValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, List<String>>> getArrayValidDelegate(Response<ResponseBody> response,
            Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, List<String>>>()
                .register(200, new TypeToken<Map<String, List<String>>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Put An array of array of strings {"0": ["1", "2", "3"], "1": ["4", "5", "6"], "2": ["7", "8", "9"]}
     *
     * @param arrayBody the Map&lt;String, List&lt;String&gt;&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putArrayValid(Map<String, List<String>> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putArrayValid(arrayBody);
            ServiceResponse<Void> response = putArrayValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Put An array of array of strings {"0": ["1", "2", "3"], "1": ["4", "5", "6"], "2": ["7", "8", "9"]}
     *
     * @param arrayBody the Map&lt;String, List&lt;String&gt;&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putArrayValidAsync(Map<String, List<String>> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putArrayValid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putArrayValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putArrayValidDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

    /**
     * Get an dictionaries of dictionaries with value null
     *
     * @return the Map&lt;String, Map&lt;String, String&gt;&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Map<String, String>> getDictionaryNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDictionaryNull();
            ServiceResponse<Map<String, Map<String, String>>> response = getDictionaryNullDelegate(call.execute(),
                    null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get an dictionaries of dictionaries with value null
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDictionaryNullAsync(
            final ServiceCallback<Map<String, Map<String, String>>> serviceCallback) {
        Call<ResponseBody> call = service.getDictionaryNull();
        call.enqueue(new ServiceResponseCallback<Map<String, Map<String, String>>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDictionaryNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Map<String, String>>> getDictionaryNullDelegate(
            Response<ResponseBody> response, Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Map<String, String>>>()
                .register(200, new TypeToken<Map<String, Map<String, String>>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get an dictionaries of dictionaries of type &lt;string, string&gt; with value {}
     *
     * @return the Map&lt;String, Map&lt;String, String&gt;&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Map<String, String>> getDictionaryEmpty() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDictionaryEmpty();
            ServiceResponse<Map<String, Map<String, String>>> response = getDictionaryEmptyDelegate(call.execute(),
                    null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get an dictionaries of dictionaries of type &lt;string, string&gt; with value {}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDictionaryEmptyAsync(
            final ServiceCallback<Map<String, Map<String, String>>> serviceCallback) {
        Call<ResponseBody> call = service.getDictionaryEmpty();
        call.enqueue(new ServiceResponseCallback<Map<String, Map<String, String>>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDictionaryEmptyDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Map<String, String>>> getDictionaryEmptyDelegate(
            Response<ResponseBody> response, Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Map<String, String>>>()
                .register(200, new TypeToken<Map<String, Map<String, String>>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get an dictionaries of dictionaries of type &lt;string, string&gt; with value {"0": {"1": "one", "2": "two", "3": "three"}, "1": null, "2": {"7": "seven", "8": "eight", "9": "nine"}}
     *
     * @return the Map&lt;String, Map&lt;String, String&gt;&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Map<String, String>> getDictionaryItemNull() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDictionaryItemNull();
            ServiceResponse<Map<String, Map<String, String>>> response = getDictionaryItemNullDelegate(
                    call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get an dictionaries of dictionaries of type &lt;string, string&gt; with value {"0": {"1": "one", "2": "two", "3": "three"}, "1": null, "2": {"7": "seven", "8": "eight", "9": "nine"}}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDictionaryItemNullAsync(
            final ServiceCallback<Map<String, Map<String, String>>> serviceCallback) {
        Call<ResponseBody> call = service.getDictionaryItemNull();
        call.enqueue(new ServiceResponseCallback<Map<String, Map<String, String>>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDictionaryItemNullDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Map<String, String>>> getDictionaryItemNullDelegate(
            Response<ResponseBody> response, Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Map<String, String>>>()
                .register(200, new TypeToken<Map<String, Map<String, String>>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get an dictionaries of dictionaries of type &lt;string, string&gt; with value {"0": {"1": "one", "2": "two", "3": "three"}, "1": {}, "2": {"7": "seven", "8": "eight", "9": "nine"}}
     *
     * @return the Map&lt;String, Map&lt;String, String&gt;&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Map<String, String>> getDictionaryItemEmpty() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDictionaryItemEmpty();
            ServiceResponse<Map<String, Map<String, String>>> response = getDictionaryItemEmptyDelegate(
                    call.execute(), null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get an dictionaries of dictionaries of type &lt;string, string&gt; with value {"0": {"1": "one", "2": "two", "3": "three"}, "1": {}, "2": {"7": "seven", "8": "eight", "9": "nine"}}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDictionaryItemEmptyAsync(
            final ServiceCallback<Map<String, Map<String, String>>> serviceCallback) {
        Call<ResponseBody> call = service.getDictionaryItemEmpty();
        call.enqueue(new ServiceResponseCallback<Map<String, Map<String, String>>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDictionaryItemEmptyDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Map<String, String>>> getDictionaryItemEmptyDelegate(
            Response<ResponseBody> response, Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Map<String, String>>>()
                .register(200, new TypeToken<Map<String, Map<String, String>>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get an dictionaries of dictionaries of type &lt;string, string&gt; with value {"0": {"1": "one", "2": "two", "3": "three"}, "1": {"4": "four", "5": "five", "6": "six"}, "2": {"7": "seven", "8": "eight", "9": "nine"}}
     *
     * @return the Map&lt;String, Map&lt;String, String&gt;&gt; object if successful.
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public Map<String, Map<String, String>> getDictionaryValid() throws ServiceException {
        try {
            Call<ResponseBody> call = service.getDictionaryValid();
            ServiceResponse<Map<String, Map<String, String>>> response = getDictionaryValidDelegate(call.execute(),
                    null);
            return response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get an dictionaries of dictionaries of type &lt;string, string&gt; with value {"0": {"1": "one", "2": "two", "3": "three"}, "1": {"4": "four", "5": "five", "6": "six"}, "2": {"7": "seven", "8": "eight", "9": "nine"}}
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> getDictionaryValidAsync(
            final ServiceCallback<Map<String, Map<String, String>>> serviceCallback) {
        Call<ResponseBody> call = service.getDictionaryValid();
        call.enqueue(new ServiceResponseCallback<Map<String, Map<String, String>>>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(getDictionaryValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Map<String, Map<String, String>>> getDictionaryValidDelegate(
            Response<ResponseBody> response, Retrofit retrofit) throws ServiceException {
        return new ServiceResponseBuilder<Map<String, Map<String, String>>>()
                .register(200, new TypeToken<Map<String, Map<String, String>>>() {
                }.getType()).registerError(new TypeToken<Error>() {
                }.getType()).build(response, retrofit);
    }

    /**
     * Get an dictionaries of dictionaries of type &lt;string, string&gt; with value {"0": {"1": "one", "2": "two", "3": "three"}, "1": {"4": "four", "5": "five", "6": "six"}, "2": {"7": "seven", "8": "eight", "9": "nine"}}
     *
     * @param arrayBody the Map&lt;String, Map&lt;String, String&gt;&gt; value
     * @throws ServiceException the exception wrapped in ServiceException if failed.
     */
    public void putDictionaryValid(Map<String, Map<String, String>> arrayBody) throws ServiceException {
        if (arrayBody == null) {
            throw new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null."));
        }
        Validator.validate(arrayBody);
        try {
            Call<ResponseBody> call = service.putDictionaryValid(arrayBody);
            ServiceResponse<Void> response = putDictionaryValidDelegate(call.execute(), null);
            response.getBody();
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException(ex);
        }
    }

    /**
     * Get an dictionaries of dictionaries of type &lt;string, string&gt; with value {"0": {"1": "one", "2": "two", "3": "three"}, "1": {"4": "four", "5": "five", "6": "six"}, "2": {"7": "seven", "8": "eight", "9": "nine"}}
     *
     * @param arrayBody the Map&lt;String, Map&lt;String, String&gt;&gt; value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     */
    public Call<ResponseBody> putDictionaryValidAsync(Map<String, Map<String, String>> arrayBody,
            final ServiceCallback<Void> serviceCallback) {
        if (arrayBody == null) {
            serviceCallback.failure(new ServiceException(
                    new IllegalArgumentException("Parameter arrayBody is required and cannot be null.")));
        }
        Validator.validate(arrayBody, serviceCallback);
        Call<ResponseBody> call = service.putDictionaryValid(arrayBody);
        call.enqueue(new ServiceResponseCallback<Void>(serviceCallback) {
            @Override
            public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
                try {
                    serviceCallback.success(putDictionaryValidDelegate(response, retrofit));
                } catch (ServiceException exception) {
                    serviceCallback.failure(exception);
                }
            }
        });
        return call;
    }

    private ServiceResponse<Void> putDictionaryValidDelegate(Response<ResponseBody> response, Retrofit retrofit)
            throws ServiceException {
        return new ServiceResponseBuilder<Void>().register(200, new TypeToken<Void>() {
        }.getType()).registerError(new TypeToken<Error>() {
        }.getType()).build(response, retrofit);
    }

}