[Java-VertX] Java Vertx client (#6204)

* #6165 - Java Vertx client

* #6165 - Java Vertx client (samples)

* #6165 - Java Vertx client (tests generation)

* #6165 - Java Vertx client (fixed test samples)

bin/java-petstore-vertx.json

@@ -0,0 +1,4 @@
+{
+    "library": "vertx",
+    "artifactId": "swagger-petstore-vertx"
+}

bin/java-petstore-vertx.sh

@@ -0,0 +1,34 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -t modules/swagger-codegen/src/main/resources/Java/libraries/vertx -i modules/swagger-codegen/src/test/resources/2_0/petstore-with-fake-endpoints-models-for-testing.yaml -l java -c bin/java-petstore-vertx.json -o samples/client/petstore/java/vertx -DhideGenerationTimestamp=true"
+
+echo "Removing files and folders under samples/client/petstore/java/vertx/src/main"
+rm -rf samples/client/petstore/java/vertx/src/main
+find samples/client/petstore/java/vertx -maxdepth 1 -type f ! -name "README.md" -exec rm {} +
+java $JAVA_OPTS -jar $executable $ags

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/JavaClientCodegen.java

@@ -70,6 +70,7 @@ public class JavaClientCodegen extends AbstractJavaCodegen
         supportedLibraries.put(RETROFIT_2, "HTTP client: OkHttp 3.8.0. JSON processing: Gson 2.6.1 (Retrofit 2.3.0). Enable the RxJava adapter using '-DuseRxJava[2]=true'. (RxJava 1.x or 2.x)");
         supportedLibraries.put("resttemplate", "HTTP client: Spring RestTemplate 4.3.9-RELEASE. JSON processing: Jackson 2.8.9");
         supportedLibraries.put("resteasy", "HTTP client: Resteasy client 3.1.3.Final. JSON processing: Jackson 2.8.9");
+        supportedLibraries.put("vertx", "HTTP client: VertX client 3.2.4. JSON processing: Jackson 2.8.9");
 
         CliOption libraryOption = new CliOption(CodegenConstants.LIBRARY, "library template (sub-template) to use");
         libraryOption.setEnum(supportedLibraries);
@@ -139,6 +140,7 @@ public class JavaClientCodegen extends AbstractJavaCodegen
 
         final String invokerFolder = (sourceFolder + '/' + invokerPackage).replace(".", "/");
         final String authFolder = (sourceFolder + '/' + invokerPackage + ".auth").replace(".", "/");
+        final String apiFolder = (sourceFolder + '/' + apiPackage).replace(".", "/");
 
         //Common files
         writeOptional(outputFolder, new SupportingFile("pom.mustache", "", "pom.xml"));
@@ -213,6 +215,15 @@ public class JavaClientCodegen extends AbstractJavaCodegen
         } else if("resttemplate".equals(getLibrary())) {
             additionalProperties.put("jackson", "true");
             supportingFiles.add(new SupportingFile("auth/Authentication.mustache", authFolder, "Authentication.java"));
+        } else if("vertx".equals(getLibrary())) {
+            typeMapping.put("file", "AsyncFile");
+            importMapping.put("AsyncFile", "io.vertx.core.file.AsyncFile");
+            setJava8Mode(true);
+            additionalProperties.put("java8", "true");
+            additionalProperties.put("jackson", "true");
+            apiTemplateFiles.put("apiImpl.mustache", "Impl.java");
+            apiTemplateFiles.put("rxApiImpl.mustache", ".java");
+            supportingFiles.remove(new SupportingFile("manifest.mustache", projectFolder, "AndroidManifest.xml"));
         } else {
             LOGGER.error("Unknown library option (-l/--library): " + getLibrary());
         }
@@ -260,6 +271,7 @@ public class JavaClientCodegen extends AbstractJavaCodegen
         return getLibrary() != null && getLibrary().contains(RETROFIT_2);
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public Map<String, Object> postProcessOperations(Map<String, Object> objs) {
         super.postProcessOperations(objs);
@@ -291,10 +303,8 @@ public class JavaClientCodegen extends AbstractJavaCodegen
             Map<String, Object> operations = (Map<String, Object>) objs.get("operations");
             List<CodegenOperation> operationList = (List<CodegenOperation>) operations.get("operation");
             for (CodegenOperation op : operationList) {
-                String path = new String(op.path);
+                String path = op.path;
                 String[] items = path.split("/", -1);
-                String opsPath = "";
-                int pathParamIndex = 0;
 
                 for (int i = 0; i < items.length; ++i) {
                     if (items[i].matches("^\\{(.*)\\}$")) { // wrap in {}
@@ -309,6 +319,20 @@ public class JavaClientCodegen extends AbstractJavaCodegen
         return objs;
     }
 
+    @Override
+    public String apiFilename(String templateName, String tag) {
+        if("vertx".equals(getLibrary())) {
+            String suffix = apiTemplateFiles().get(templateName);
+            String subFolder = "";
+            if (templateName.startsWith("rx")) {
+                subFolder = "/rxjava";
+            }
+            return apiFileFolder() + subFolder + '/' + toApiFilename(tag) + suffix;
+        } else {
+            return super.apiFilename(templateName, tag);
+        }
+    }
+
     /**
      *  Prioritizes consumes mime-type list by moving json-vendor and json mime-types up front, but
      *  otherwise preserves original consumes definition order.
@@ -384,6 +408,7 @@ public class JavaClientCodegen extends AbstractJavaCodegen
         }
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public Map<String, Object> postProcessModelsEnum(Map<String, Object> objs) {
         objs = super.postProcessModelsEnum(objs);

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/ApiClient.mustache

@@ -0,0 +1,599 @@
+package {{invokerPackage}};
+
+import {{invokerPackage}}.auth.Authentication;
+import {{invokerPackage}}.auth.HttpBasicAuth;
+import {{invokerPackage}}.auth.ApiKeyAuth;
+import {{invokerPackage}}.auth.OAuth;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import io.vertx.core.*;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.file.AsyncFile;
+import io.vertx.core.file.FileSystem;
+import io.vertx.core.file.OpenOptions;
+import io.vertx.core.http.HttpHeaders;
+import io.vertx.core.http.HttpMethod;
+import io.vertx.core.json.Json;
+import io.vertx.core.json.JsonObject;
+import io.vertx.ext.web.client.HttpRequest;
+import io.vertx.ext.web.client.HttpResponse;
+import io.vertx.ext.web.client.WebClient;
+import io.vertx.ext.web.client.WebClientOptions;
+
+import java.text.DateFormat;
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static java.util.stream.Collectors.toMap;
+
+{{>generatedAnnotation}}
+public class ApiClient {
+
+    private static final Pattern CONTENT_DISPOSITION_PATTERN = Pattern.compile("filename=['\"]?([^'\"\\s]+)['\"]?");
+    private static final OpenOptions FILE_DOWNLOAD_OPTIONS = new OpenOptions().setCreate(true).setTruncateExisting(true);
+
+    private final Vertx vertx;
+
+    private MultiMap defaultHeaders = MultiMap.caseInsensitiveMultiMap();
+    private Map<String, Authentication> authentications;
+    private WebClient webClient;
+    private String basePath = "{{{basePath}}}";
+    private DateFormat dateFormat;
+    private ObjectMapper objectMapper;
+    private String downloadsDir = "";
+
+    public ApiClient(Vertx vertx, JsonObject config) {
+        Objects.requireNonNull(vertx, "Vertx must not be null");
+        Objects.requireNonNull(config, "Config must not be null");
+
+        this.vertx = vertx;
+
+        // Use RFC3339 format for date and datetime.
+        // See http://xml2rfc.ietf.org/public/rfc/html/rfc3339.html#anchor14
+        this.dateFormat = new RFC3339DateFormat();
+
+        // Use UTC as the default time zone.
+        this.dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+
+        // Build object mapper
+        this.objectMapper = new ObjectMapper();
+        this.objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+        this.objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        this.objectMapper.configure(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE, false);
+        this.objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+        this.objectMapper.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
+        this.objectMapper.enable(DeserializationFeature.READ_ENUMS_USING_TO_STRING);
+        this.objectMapper.registerModule(new JavaTimeModule());
+        this.objectMapper.setDateFormat(dateFormat);
+
+        // Setup authentications (key: authentication name, value: authentication).
+        this.authentications = new HashMap<>();{{#authMethods}}{{#isBasic}}
+        authentications.put("{{name}}", new HttpBasicAuth());{{/isBasic}}{{#isApiKey}}
+        authentications.put("{{name}}", new ApiKeyAuth({{#isKeyInHeader}}"header"{{/isKeyInHeader}}{{^isKeyInHeader}}"query"{{/isKeyInHeader}}, "{{keyParamName}}"));{{/isApiKey}}{{#isOAuth}}
+        authentications.put("{{name}}", new OAuth());{{/isOAuth}}{{/authMethods}}
+        // Prevent the authentications from being modified.
+        this.authentications = Collections.unmodifiableMap(authentications);
+
+        // Configurations
+        this.basePath = config.getString("basePath", this.basePath);
+        this.downloadsDir = config.getString("downloadsDir", this.downloadsDir);
+
+        // Build WebClient
+        this.webClient = buildWebClient(vertx, config);
+    }
+
+    public Vertx getVertx() {
+        return vertx;
+    }
+
+    public ObjectMapper getObjectMapper() {
+        return objectMapper;
+    }
+
+    public ApiClient setObjectMapper(ObjectMapper objectMapper) {
+        this.objectMapper = objectMapper;
+        return this;
+    }
+
+    public WebClient getWebClient() {
+        return webClient;
+    }
+
+    public ApiClient setWebClient(WebClient webClient) {
+        this.webClient = webClient;
+        return this;
+    }
+
+    public String getBasePath() {
+        return basePath;
+    }
+
+    public ApiClient setBasePath(String basePath) {
+        this.basePath = basePath;
+        return this;
+    }
+
+    public String getDownloadsDir() {
+        return downloadsDir;
+    }
+
+    public ApiClient setDownloadsDir(String downloadsDir) {
+        this.downloadsDir = downloadsDir;
+        return this;
+    }
+
+    public MultiMap getDefaultHeaders() {
+        return defaultHeaders;
+    }
+
+    public ApiClient addDefaultHeader(String key, String value) {
+        defaultHeaders.add(key, value);
+        return this;
+    }
+
+    /**
+     * Get authentications (key: authentication name, value: authentication).
+     *
+     * @return Map of authentication object
+     */
+    public Map<String, Authentication> getAuthentications() {
+        return authentications;
+    }
+
+    /**
+     * Get authentication for the given name.
+     *
+     * @param authName The authentication name
+     * @return The authentication, null if not found
+     */
+    public Authentication getAuthentication(String authName) {
+        return authentications.get(authName);
+    }
+
+    /**
+     * Helper method to set username for the first HTTP basic authentication.
+     *
+     * @param username Username
+     */
+    public ApiClient setUsername(String username) {
+        for (Authentication auth : authentications.values()) {
+            if (auth instanceof HttpBasicAuth) {
+                ((HttpBasicAuth) auth).setUsername(username);
+                return this;
+            }
+        }
+        throw new RuntimeException("No HTTP basic authentication configured!");
+    }
+
+    /**
+     * Helper method to set password for the first HTTP basic authentication.
+     *
+     * @param password Password
+     */
+    public ApiClient setPassword(String password) {
+        for (Authentication auth : authentications.values()) {
+            if (auth instanceof HttpBasicAuth) {
+                ((HttpBasicAuth) auth).setPassword(password);
+                return this;
+            }
+        }
+        throw new RuntimeException("No HTTP basic authentication configured!");
+    }
+
+    /**
+     * Helper method to set API key value for the first API key authentication.
+     *
+     * @param apiKey API key
+     */
+    public ApiClient setApiKey(String apiKey) {
+        for (Authentication auth : authentications.values()) {
+            if (auth instanceof ApiKeyAuth) {
+                ((ApiKeyAuth) auth).setApiKey(apiKey);
+                return this;
+            }
+        }
+        throw new RuntimeException("No API key authentication configured!");
+    }
+
+    /**
+     * Helper method to set API key prefix for the first API key authentication.
+     *
+     * @param apiKeyPrefix API key prefix
+     */
+    public ApiClient setApiKeyPrefix(String apiKeyPrefix) {
+        for (Authentication auth : authentications.values()) {
+            if (auth instanceof ApiKeyAuth) {
+                ((ApiKeyAuth) auth).setApiKeyPrefix(apiKeyPrefix);
+                return this;
+            }
+        }
+        throw new RuntimeException("No API key authentication configured!");
+    }
+
+    /**
+     * Helper method to set access token for the first OAuth2 authentication.
+     *
+     * @param accessToken Access token
+     */
+    public ApiClient setAccessToken(String accessToken) {
+        for (Authentication auth : authentications.values()) {
+            if (auth instanceof OAuth) {
+                ((OAuth) auth).setAccessToken(accessToken);
+                return this;
+            }
+        }
+        throw new RuntimeException("No OAuth2 authentication configured!");
+    }
+
+    /**
+     * Format the given Date object into string.
+     *
+     * @param date Date
+     * @return Date in string format
+     */
+    public String formatDate(Date date) {
+        return dateFormat.format(date);
+    }
+
+    /**
+     * Format the given parameter object into string.
+     *
+     * @param param Object
+     * @return Object in string format
+     */
+    public String parameterToString(Object param) {
+        if (param == null) {
+            return "";
+        } else if (param instanceof Date) {
+            return formatDate((Date) param);
+        } else if (param instanceof Collection) {
+            StringBuilder b = new StringBuilder();
+            for (Object o : (Collection) param) {
+                if (b.length() > 0) {
+                    b.append(',');
+                }
+                b.append(String.valueOf(o));
+            }
+            return b.toString();
+        } else {
+            return String.valueOf(param);
+        }
+    }
+
+    /*
+     * Format to {@code Pair} objects.
+     * @param collectionFormat Collection format
+     * @param name Name
+     * @param value Value
+     * @return List of pairs
+     */
+    public List<Pair> parameterToPairs(String collectionFormat, String name, Object value) {
+        List<Pair> params = new ArrayList<Pair>();
+
+        // preconditions
+        if (name == null || name.isEmpty() || value == null) return params;
+
+        Collection valueCollection;
+        if (value instanceof Collection) {
+            valueCollection = (Collection) value;
+        } else {
+            params.add(new Pair(name, parameterToString(value)));
+            return params;
+        }
+
+        if (valueCollection.isEmpty()) {
+            return params;
+        }
+
+        // get the collection format (default: csv)
+        String format = (collectionFormat == null || collectionFormat.isEmpty() ? "csv" : collectionFormat);
+
+        // create the params based on the collection format
+        if ("multi".equals(format)) {
+            for (Object item : valueCollection) {
+                params.add(new Pair(name, parameterToString(item)));
+            }
+            return params;
+        }
+
+        String delimiter = ",";
+        if ("csv".equals(format)) {
+            delimiter = ",";
+        } else if ("ssv".equals(format)) {
+            delimiter = " ";
+        } else if ("tsv".equals(format)) {
+            delimiter = "\t";
+        } else if ("pipes".equals(format)) {
+            delimiter = "|";
+        }
+
+        StringBuilder sb = new StringBuilder();
+        for (Object item : valueCollection) {
+            sb.append(delimiter);
+            sb.append(parameterToString(item));
+        }
+
+        params.add(new Pair(name, sb.substring(1)));
+
+        return params;
+    }
+
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     * application/json
+     * application/json; charset=UTF8
+     * APPLICATION/JSON
+     * application/vnd.company+json
+     *
+     * @param mime MIME
+     * @return True if the MIME type is JSON
+     */
+    private boolean isJsonMime(String mime) {
+        String jsonMime = "(?i)^(application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(;.*)?$";
+        return mime != null && (mime.matches(jsonMime) || mime.equalsIgnoreCase("application/json-patch+json"));
+    }
+
+    /**
+     * Select the Accept header's value from the given accepts array:
+     * if JSON exists in the given array, use it;
+     * otherwise use all of them (joining into a string)
+     *
+     * @param accepts The accepts array to select from
+     * @return The Accept header to use. If the given array is empty,
+     * null will be returned (not to set the Accept header explicitly).
+     */
+    protected String selectHeaderAccept(String[] accepts) {
+        if (accepts.length == 0) {
+            return null;
+        }
+        for (String accept : accepts) {
+            if (isJsonMime(accept)) {
+                return accept;
+            }
+        }
+        return StringUtil.join(accepts, ",");
+    }
+
+    /**
+     * Select the Content-Type header's value from the given array:
+     * if JSON exists in the given array, use it;
+     * otherwise use the first one of the array.
+     *
+     * @param contentTypes The Content-Type array to select from
+     * @return The Content-Type header to use. If the given array is empty,
+     * JSON will be used.
+     */
+    protected String selectHeaderContentType(String[] contentTypes) {
+        if (contentTypes.length == 0) {
+            return "application/json";
+        }
+        for (String contentType : contentTypes) {
+            if (isJsonMime(contentType)) {
+                return contentType;
+            }
+        }
+        return contentTypes[0];
+    }
+
+    public void sendBody(HttpRequest<Buffer> request,
+                         Handler<AsyncResult<HttpResponse<Buffer>>> responseHandler,
+                         Object body) {
+        if (body instanceof byte[]) {
+            Buffer buffer = Buffer.buffer((byte[]) body);
+            request.sendBuffer(buffer, responseHandler);
+        } else if (body instanceof AsyncFile) {
+            AsyncFile file = (AsyncFile) body;
+            request.sendStream(file, responseHandler);
+        } else {
+            request.sendJson(body, responseHandler);
+        }
+    }
+
+    /**
+     * Invoke API by sending HTTP request with the given options.
+     *
+     * @param <T> Type
+     * @param path The sub-path of the HTTP URL
+     * @param method The request method, one of "GET", "POST", "PUT", "HEAD" and "DELETE"
+     * @param queryParams The query parameters
+     * @param body The request body object
+     * @param headerParams The header parameters
+     * @param formParams The form parameters
+     * @param accepts The request's Accept headers
+     * @param contentTypes The request's Content-Type headers
+     * @param authNames The authentications to apply
+     * @param returnType The return type into which to deserialize the response
+     * @param resultHandler The asynchronous response handler
+     */
+    public <T> void invokeAPI(String path, String method, List<Pair> queryParams, Object body, MultiMap headerParams,
+                              Map<String, Object> formParams, String[] accepts, String[] contentTypes, String[] authNames,
+                              TypeReference<T> returnType, Handler<AsyncResult<T>> resultHandler) {
+
+        updateParamsForAuth(authNames, queryParams, headerParams);
+
+        if (accepts != null) {
+            headerParams.add(HttpHeaders.ACCEPT, selectHeaderAccept(accepts));
+        }
+
+        if (contentTypes != null) {
+            headerParams.add(HttpHeaders.CONTENT_TYPE, selectHeaderContentType(contentTypes));
+        }
+
+        HttpMethod httpMethod = HttpMethod.valueOf(method);
+        HttpRequest<Buffer> request = webClient.requestAbs(httpMethod, basePath + path);
+
+        if (httpMethod == HttpMethod.PATCH) {
+            request.putHeader("X-HTTP-Method-Override", "PATCH");
+        }
+
+        queryParams.forEach(entry -> {
+            if (entry.getValue() != null) {
+                request.addQueryParam(entry.getName(), entry.getValue());
+            }
+        });
+
+        headerParams.forEach(entry -> {
+            if (entry.getValue() != null) {
+                request.putHeader(entry.getKey(), entry.getValue());
+            }
+        });
+
+        defaultHeaders.forEach(entry -> {
+            if (entry.getValue() != null) {
+                request.putHeader(entry.getKey(), entry.getValue());
+            }
+        });
+
+        Handler<AsyncResult<HttpResponse<Buffer>>> responseHandler = buildResponseHandler(returnType, resultHandler);
+        if (body != null) {
+            sendBody(request, responseHandler, body);
+        } else if (formParams != null && !formParams.isEmpty()) {
+            Map<String, String> formMap = formParams.entrySet().stream().collect(toMap(Map.Entry::getKey, entry -> parameterToString(entry.getValue())));
+            MultiMap form = MultiMap.caseInsensitiveMultiMap().addAll(formMap);
+            request.sendForm(form, responseHandler);
+        } else {
+            request.send(responseHandler);
+        }
+    }
+
+    /**
+     * Sanitize filename by removing path.
+     * e.g. ../../sun.gif becomes sun.gif
+     *
+     * @param filename The filename to be sanitized
+     * @return The sanitized filename
+     */
+    protected String sanitizeFilename(String filename) {
+        return filename.replaceAll(".*[/\\\\]", "");
+    }
+
+    /**
+     * Create a filename from the given headers.
+     * When the headers have no "Content-Disposition" information, a random UUID name is generated.
+     *
+     * @param headers The HTTP response headers
+     * @return The filename
+     */
+    protected String generateFilename(MultiMap headers) {
+        String filename = UUID.randomUUID().toString();
+        String contentDisposition = headers.get("Content-Disposition");
+        if (contentDisposition != null && !contentDisposition.isEmpty()) {
+            Matcher matcher = CONTENT_DISPOSITION_PATTERN.matcher(contentDisposition);
+            if (matcher.find()) {
+                filename = sanitizeFilename(matcher.group(1));
+            }
+        }
+        return filename;
+    }
+
+    /**
+     * File Download handling.
+     *
+     * @param response The HTTP response
+     * @param handler The response handler
+     */
+    protected <T> void handleFileDownload(HttpResponse<Buffer> response, Handler<AsyncResult<T>> handler) {
+        FileSystem fs = getVertx().fileSystem();
+
+        String filename = generateFilename(response.headers());
+        Consumer<String> fileHandler = directory -> {
+            fs.open(directory + filename, FILE_DOWNLOAD_OPTIONS, asyncFileResult -> {
+                if (asyncFileResult.succeeded()) {
+                    AsyncFile asyncFile = asyncFileResult.result();
+                    asyncFile.write(response.bodyAsBuffer());
+                    //noinspection unchecked
+                    handler.handle(Future.succeededFuture((T) asyncFile));
+                } else {
+                    handler.handle(ApiException.fail(asyncFileResult.cause()));
+                }
+            });
+        };
+
+        String dir = getDownloadsDir();
+        if (dir != null && !dir.isEmpty()) {
+            fs.mkdirs(dir, mkdirResult -> {
+                String sanitizedFolder = dir.endsWith("/") ? dir : dir + "/";
+                fileHandler.accept(sanitizedFolder);
+            });
+        } else {
+            fileHandler.accept("");
+        }
+    }
+
+    /**
+     * Build a response handler for the HttpResponse.
+     *
+     * @param returnType The return type
+     * @param handler The response handler
+     * @return The HTTP response handler
+     */
+    protected <T> Handler<AsyncResult<HttpResponse<Buffer>>> buildResponseHandler(TypeReference<T> returnType,
+                                                                                  Handler<AsyncResult<T>> handler) {
+        return response -> {
+            AsyncResult<T> result;
+            if (response.succeeded()) {
+                HttpResponse<Buffer> httpResponse = response.result();
+                if (httpResponse.statusCode() / 100 == 2) {
+                    if (httpResponse.statusCode() == 204 || returnType == null) {
+                        result = Future.succeededFuture(null);
+                    } else {
+                        T resultContent;
+                        if ("byte[]".equals(returnType.getType().toString())) {
+                            resultContent = (T) httpResponse.body().getBytes();
+                        } else if (AsyncFile.class.equals(returnType.getType())) {
+                            handleFileDownload(httpResponse, handler);
+                            return;
+                        } else {
+                            resultContent = Json.decodeValue(httpResponse.body(), returnType);
+                        }
+                        result = Future.succeededFuture(resultContent);
+                    }
+                } else {
+                    result = ApiException.fail(httpResponse.statusMessage(), httpResponse.statusCode(), httpResponse.headers(), httpResponse.bodyAsString());
+                }
+            } else if (response.cause() instanceof ApiException) {
+                result = Future.failedFuture(response.cause());
+            } else {
+                result = ApiException.fail(500, response.cause() != null ? response.cause().getMessage() : null);
+            }
+            handler.handle(result);
+        };
+    }
+
+    /**
+     * Build the WebClient used to make HTTP requests.
+     *
+     * @param vertx Vertx
+     * @return WebClient
+     */
+    protected WebClient buildWebClient(Vertx vertx, JsonObject config) {
+
+        if (!config.containsKey("userAgent")) {
+            config.put("userAgent", "{{#httpUserAgent}}{{{.}}}{{/httpUserAgent}}{{^httpUserAgent}}Swagger-Codegen/{{{artifactVersion}}}/java{{/httpUserAgent}}");
+        }
+
+        return WebClient.create(vertx, new WebClientOptions(config));
+    }
+
+
+    /**
+     * Update query and header parameters based on authentication settings.
+     *
+     * @param authNames The authentications to apply
+     */
+    protected void updateParamsForAuth(String[] authNames, List<Pair> queryParams, MultiMap headerParams) {
+        for (String authName : authNames) {
+            Authentication auth = authentications.get(authName);
+            if (auth == null) throw new RuntimeException("Authentication undefined: " + authName);
+            auth.applyToParams(queryParams, headerParams);
+        }
+    }
+}

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/Configuration.mustache

@@ -0,0 +1,42 @@
+package {{invokerPackage}};
+
+import io.vertx.core.Vertx;
+import io.vertx.core.json.JsonObject;
+
+import java.util.Objects;
+
+public class Configuration {
+
+    private static ApiClient defaultApiClient = null;
+
+    /**
+     * Setup the default API client.
+     * Will be used by API instances when a client is not provided.
+     *
+     * @return Default API client
+     */
+    public synchronized static ApiClient setupDefaultApiClient(Vertx vertx, JsonObject config) {
+        defaultApiClient = new ApiClient(vertx, config);
+        return defaultApiClient;
+    }
+
+    /**
+     * Get the default API client, which would be used when creating API
+     * instances without providing an API client.
+     *
+     * @return Default API client
+     */
+    public synchronized static ApiClient getDefaultApiClient() {
+        return defaultApiClient;
+    }
+
+    /**
+     * Set the default API client, which would be used when creating API
+     * instances without providing an API client.
+     *
+     * @param apiClient API client
+     */
+    public synchronized static void setDefaultApiClient(ApiClient apiClient) {
+        defaultApiClient = apiClient;
+    }
+}

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/api.mustache

@@ -0,0 +1,19 @@
+package {{package}};
+
+{{#imports}}import {{import}};
+{{/imports}}
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.json.JsonObject;
+
+import java.util.*;
+
+public interface {{classname}} {
+
+    {{#operations}}
+    {{#operation}}
+    void {{operationId}}({{#allParams}}{{{dataType}}} {{paramName}}, {{/allParams}}Handler<AsyncResult<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}Void{{/returnType}}>> handler);
+
+    {{/operation}}
+    {{/operations}}
+}

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/apiException.mustache

@@ -0,0 +1,110 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}};
+
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Future;
+import io.vertx.core.MultiMap;
+
+{{>generatedAnnotation}}
+public class ApiException extends{{#useRuntimeException}} RuntimeException {{/useRuntimeException}}{{^useRuntimeException}} Exception {{/useRuntimeException}}{
+    private int code = 0;
+    private MultiMap responseHeaders = null;
+    private String responseBody = null;
+
+
+    public static <T> AsyncResult<T> fail(int failureCode, String message) {
+        return Future.failedFuture(new ApiException(failureCode, message));
+    }
+
+    public static <T> AsyncResult<T> fail(Throwable throwable) {
+        return Future.failedFuture(new ApiException(throwable));
+    }
+
+    public static <T> AsyncResult<T> fail(String message) {
+        return Future.failedFuture(new ApiException(message));
+    }
+
+    public static <T> AsyncResult<T> fail(String message, Throwable throwable, int code, MultiMap responseHeaders) {
+        return Future.failedFuture(new ApiException(message, throwable, code, responseHeaders, null));
+    }
+
+    public static <T> AsyncResult<T> fail(String message, Throwable throwable, int code, MultiMap responseHeaders, String responseBody) {
+        return Future.failedFuture(new ApiException(message, throwable, code, responseHeaders, responseBody));
+    }
+
+    public static <T> AsyncResult<T> fail(String message, int code, MultiMap responseHeaders, String responseBody) {
+        return Future.failedFuture(new ApiException(message, (Throwable) null, code, responseHeaders, responseBody));
+    }
+
+    public static <T> AsyncResult<T> fail(int code, MultiMap responseHeaders, String responseBody) {
+        return Future.failedFuture(new ApiException((String) null, (Throwable) null, code, responseHeaders, responseBody));
+    }
+
+    public ApiException() {}
+
+    public ApiException(Throwable throwable) {
+        super(throwable);
+    }
+
+    public ApiException(String message) {
+        super(message);
+    }
+
+    public ApiException(String message, Throwable throwable, int code, MultiMap responseHeaders, String responseBody) {
+        super(message, throwable);
+        this.code = code;
+        this.responseHeaders = responseHeaders;
+        this.responseBody = responseBody;
+    }
+
+    public ApiException(String message, int code, MultiMap responseHeaders, String responseBody) {
+        this(message, (Throwable) null, code, responseHeaders, responseBody);
+    }
+
+    public ApiException(String message, Throwable throwable, int code, MultiMap responseHeaders) {
+        this(message, throwable, code, responseHeaders, null);
+    }
+
+    public ApiException(int code, MultiMap responseHeaders, String responseBody) {
+        this((String) null, (Throwable) null, code, responseHeaders, responseBody);
+    }
+
+    public ApiException(int code, String message) {
+        super(message);
+        this.code = code;
+    }
+
+    public ApiException(int code, String message, MultiMap responseHeaders, String responseBody) {
+        this(code, message);
+        this.responseHeaders = responseHeaders;
+        this.responseBody = responseBody;
+    }
+
+    /**
+     * Get the HTTP status code.
+     *
+     * @return HTTP status code
+     */
+    public int getCode() {
+        return code;
+    }
+
+    /**
+     * Get the HTTP response headers.
+     *
+     * @return A map of list of string
+     */
+    public MultiMap getResponseHeaders() {
+        return responseHeaders;
+    }
+
+    /**
+     * Get the HTTP response body.
+     *
+     * @return Response body in the form of string
+     */
+    public String getResponseBody() {
+        return responseBody;
+    }
+}

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/apiImpl.mustache

@@ -0,0 +1,91 @@
+package {{package}};
+
+{{#imports}}import {{import}};
+{{/imports}}
+
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.json.JsonObject;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+
+import java.util.*;
+
+import {{invokerPackage}}.ApiClient;
+import {{invokerPackage}}.ApiException;
+import {{invokerPackage}}.Configuration;
+import {{invokerPackage}}.Pair;
+
+{{>generatedAnnotation}}
+{{#operations}}
+public class {{classname}}Impl implements {{classname}} {
+
+    private ApiClient {{localVariablePrefix}}apiClient;
+
+    public {{classname}}Impl() {
+        this(null);
+    }
+
+    public {{classname}}Impl(ApiClient apiClient) {
+        this.{{localVariablePrefix}}apiClient = apiClient != null ? apiClient : Configuration.getDefaultApiClient();
+    }
+
+    public ApiClient getApiClient() {
+        return {{localVariablePrefix}}apiClient;
+    }
+
+    public void setApiClient(ApiClient apiClient) {
+        this.{{localVariablePrefix}}apiClient = apiClient;
+    }
+
+    {{#operation}}
+    /**
+     * {{summary}}
+     * {{notes}}
+     {{#allParams}}
+     * @param {{paramName}} {{description}}{{#required}} (required){{/required}}{{^required}} (optional{{#defaultValue}}, default to {{{.}}}{{/defaultValue}}){{/required}}
+     {{/allParams}}
+     * @param resultHandler Asynchronous result handler
+     */
+    public void {{operationId}}({{#allParams}}{{{dataType}}} {{paramName}}, {{/allParams}}Handler<AsyncResult<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}Void{{/returnType}}>> resultHandler) {
+        Object {{localVariablePrefix}}localVarBody = {{#bodyParam}}{{paramName}}{{/bodyParam}}{{^bodyParam}}null{{/bodyParam}};
+        {{#allParams}}{{#required}}
+        // verify the required parameter '{{paramName}}' is set
+        if ({{paramName}} == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter '{{paramName}}' when calling {{operationId}}"));
+            return;
+        }
+        {{/required}}{{/allParams}}
+        // create path and map variables
+        String {{localVariablePrefix}}localVarPath = "{{{path}}}"{{#pathParams}}.replaceAll("\\{" + "{{baseName}}" + "\\}", {{{paramName}}}.toString()){{/pathParams}};
+
+        // query params
+        List<Pair> {{localVariablePrefix}}localVarQueryParams = new ArrayList<>();
+        {{#queryParams}}
+        {{localVariablePrefix}}localVarQueryParams.addAll({{localVariablePrefix}}apiClient.parameterToPairs("{{#collectionFormat}}{{{collectionFormat}}}{{/collectionFormat}}", "{{baseName}}", {{paramName}}));
+        {{/queryParams}}
+
+        // header params
+        MultiMap {{localVariablePrefix}}localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        {{#headerParams}}if ({{paramName}} != null)
+        {{localVariablePrefix}}localVarHeaderParams.add("{{baseName}}", {{localVariablePrefix}}apiClient.parameterToString({{paramName}}));
+        {{/headerParams}}
+
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> {{localVariablePrefix}}localVarFormParams = new HashMap<>();
+        {{#formParams}}if ({{paramName}} != null) {{localVariablePrefix}}localVarFormParams.put("{{baseName}}", {{paramName}});
+        {{/formParams}}
+
+        String[] {{localVariablePrefix}}localVarAccepts = { {{#produces}}"{{{mediaType}}}"{{#hasMore}}, {{/hasMore}}{{/produces}} };
+        String[] {{localVariablePrefix}}localVarContentTypes = { {{#consumes}}"{{{mediaType}}}"{{#hasMore}}, {{/hasMore}}{{/consumes}} };
+        String[] {{localVariablePrefix}}localVarAuthNames = new String[] { {{#authMethods}}"{{name}}"{{#hasMore}}, {{/hasMore}}{{/authMethods}} };
+        {{#returnType}}
+        TypeReference<{{{returnType}}}> {{localVariablePrefix}}localVarReturnType = new TypeReference<{{{returnType}}}>() {};
+        {{localVariablePrefix}}apiClient.invokeAPI({{localVariablePrefix}}localVarPath, "{{httpMethod}}", {{localVariablePrefix}}localVarQueryParams, {{localVariablePrefix}}localVarBody, {{localVariablePrefix}}localVarHeaderParams, {{localVariablePrefix}}localVarFormParams, {{localVariablePrefix}}localVarAccepts, {{localVariablePrefix}}localVarContentTypes, {{localVariablePrefix}}localVarAuthNames, {{localVariablePrefix}}localVarReturnType, resultHandler);{{/returnType}}{{^returnType}}
+        {{localVariablePrefix}}apiClient.invokeAPI({{localVariablePrefix}}localVarPath, "{{httpMethod}}", {{localVariablePrefix}}localVarQueryParams, {{localVariablePrefix}}localVarBody, {{localVariablePrefix}}localVarHeaderParams, {{localVariablePrefix}}localVarFormParams, {{localVariablePrefix}}localVarAccepts, {{localVariablePrefix}}localVarContentTypes, {{localVariablePrefix}}localVarAuthNames, null, resultHandler);{{/returnType}}
+    }
+    {{/operation}}
+}
+{{/operations}}

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/api_test.mustache

@@ -0,0 +1,70 @@
+{{>licenseInfo}}
+package {{package}};
+
+{{#imports}}import {{import}};
+{{/imports}}
+
+import {{invokerPackage}}.Configuration;
+
+import org.junit.Test;
+import org.junit.Ignore;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.runner.RunWith;
+
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.json.JsonObject;
+import io.vertx.core.Vertx;
+import io.vertx.ext.unit.junit.VertxUnitRunner;
+import io.vertx.ext.unit.junit.RunTestOnContext;
+import io.vertx.ext.unit.TestContext;
+import io.vertx.ext.unit.Async;
+
+{{^fullJavaUtil}}
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+{{/fullJavaUtil}}
+
+/**
+ * API tests for {{classname}}
+ */
+@RunWith(VertxUnitRunner.class)
+@Ignore
+public class {{classname}}Test {
+
+    private {{classname}} api;
+
+    @Rule
+    public RunTestOnContext rule = new RunTestOnContext();
+
+    @BeforeClass
+    public void setupApiClient() {
+        JsonObject config = new JsonObject();
+        Vertx vertx = rule.vertx();
+        Configuration.setupDefaultApiClient(vertx, config);
+
+        api = new {{classname}}Impl();
+    }
+    {{#operations}}{{#operation}}
+    /**
+     * {{summary}}
+     * {{notes}}
+     *
+     * @param context Vertx test context for doing assertions
+     */
+    @Test
+    public void {{operationId}}Test(TestContext context) {
+        Async async = context.async();
+        {{#allParams}}
+        {{{dataType}}} {{paramName}} = null;
+        {{/allParams}}
+        api.{{operationId}}({{#allParams}}{{paramName}}, {{/allParams}}result -> {
+            // TODO: test validations
+            async.complete();
+        });
+    }
+    {{/operation}}{{/operations}}
+}

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/auth/ApiKeyAuth.mustache

@@ -0,0 +1,64 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}}.auth;
+
+import {{invokerPackage}}.Pair;
+import io.vertx.core.MultiMap;
+
+import java.util.List;
+
+{{>generatedAnnotation}}
+public class ApiKeyAuth implements Authentication {
+  private final String location;
+  private final String paramName;
+
+  private String apiKey;
+  private String apiKeyPrefix;
+
+  public ApiKeyAuth(String location, String paramName) {
+    this.location = location;
+    this.paramName = paramName;
+  }
+
+  public String getLocation() {
+    return location;
+  }
+
+  public String getParamName() {
+    return paramName;
+  }
+
+  public String getApiKey() {
+    return apiKey;
+  }
+
+  public void setApiKey(String apiKey) {
+    this.apiKey = apiKey;
+  }
+
+  public String getApiKeyPrefix() {
+    return apiKeyPrefix;
+  }
+
+  public void setApiKeyPrefix(String apiKeyPrefix) {
+    this.apiKeyPrefix = apiKeyPrefix;
+  }
+
+  @Override
+  public void applyToParams(List<Pair> queryParams, MultiMap headerParams) {
+    if (apiKey == null) {
+      return;
+    }
+    String value;
+    if (apiKeyPrefix != null) {
+      value = apiKeyPrefix + " " + apiKey;
+    } else {
+      value = apiKey;
+    }
+    if ("query".equals(location)) {
+      queryParams.add(new Pair(paramName, value));
+    } else if ("header".equals(location)) {
+      headerParams.add(paramName, value);
+    }
+  }
+}

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/auth/Authentication.mustache

@@ -0,0 +1,18 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}}.auth;
+
+import {{invokerPackage}}.Pair;
+import io.vertx.core.MultiMap;
+
+import java.util.List;
+
+public interface Authentication {
+    /**
+     * Apply authentication settings to header and query params.
+     *
+     * @param queryParams List of query parameters
+     * @param headerParams Map of header parameters
+     */
+    void applyToParams(List<Pair> queryParams, MultiMap headerParams);
+}

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/auth/HttpBasicAuth.mustache

@@ -0,0 +1,40 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}}.auth;
+
+import {{invokerPackage}}.Pair;
+import io.vertx.core.MultiMap;
+import java.util.Base64;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+{{>generatedAnnotation}}
+public class HttpBasicAuth implements Authentication {
+  private String username;
+  private String password;
+
+  public String getUsername() {
+    return username;
+  }
+
+  public void setUsername(String username) {
+    this.username = username;
+  }
+
+  public String getPassword() {
+    return password;
+  }
+
+  public void setPassword(String password) {
+    this.password = password;
+  }
+
+  @Override
+  public void applyToParams(List<Pair> queryParams, MultiMap headerParams) {
+    if (username == null && password == null) {
+      return;
+    }
+    String str = (username == null ? "" : username) + ":" + (password == null ? "" : password);
+    headerParams.add("Authorization", "Basic " + Base64.getEncoder().encodeToString(str.getBytes(StandardCharsets.UTF_8)));
+  }
+}

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/auth/OAuth.mustache

@@ -0,0 +1,28 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}}.auth;
+
+import {{invokerPackage}}.Pair;
+import io.vertx.core.MultiMap;
+
+import java.util.List;
+
+{{>generatedAnnotation}}
+public class OAuth implements Authentication {
+  private String accessToken;
+
+  public String getAccessToken() {
+    return accessToken;
+  }
+
+  public void setAccessToken(String accessToken) {
+    this.accessToken = accessToken;
+  }
+
+  @Override
+  public void applyToParams(List<Pair> queryParams, MultiMap headerParams) {
+    if (accessToken != null) {
+      headerParams.add("Authorization", "Bearer " + accessToken);
+    }
+  }
+}

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/auth/OAuthFlow.mustache

@@ -0,0 +1,7 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}}.auth;
+
+public enum OAuthFlow {
+    accessCode, implicit, password, application
+}

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/build.gradle.mustache

@@ -0,0 +1,53 @@
+apply plugin: 'idea'
+apply plugin: 'eclipse'
+
+group = '{{groupId}}'
+version = '{{artifactVersion}}'
+
+repositories {
+    jcenter()
+}
+
+apply plugin: 'java'
+apply plugin: 'maven'
+
+sourceCompatibility = JavaVersion.VERSION_1_8
+targetCompatibility = JavaVersion.VERSION_1_8
+
+install {
+    repositories.mavenInstaller {
+        pom.artifactId = '{{artifactId}}'
+    }
+}
+
+task execute(type:JavaExec) {
+   main = System.getProperty('mainClass')
+   classpath = sourceSets.main.runtimeClasspath
+}
+
+ext {
+    swagger_annotations_version = "1.5.15"
+    jackson_version = "{{^threetenbp}}2.8.9{{/threetenbp}}{{#threetenbp}}2.6.4{{/threetenbp}}"
+    vertx_version = "3.4.2"
+    junit_version = "4.12"
+}
+
+dependencies {
+    compile "io.swagger:swagger-annotations:$swagger_annotations_version"
+    compile "io.vertx:vertx-web-client:$vertx_version"
+    compile "io.vertx:vertx-rx-java:$vertx_version"
+    compile "com.fasterxml.jackson.core:jackson-core:$jackson_version"
+    compile "com.fasterxml.jackson.core:jackson-annotations:$jackson_version"
+    compile "com.fasterxml.jackson.core:jackson-databind:$jackson_version"
+    {{#joda}}
+    compile "com.fasterxml.jackson.datatype:jackson-datatype-joda:$jackson_version"
+    {{/joda}}
+    {{#java8}}
+    compile "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:$jackson_version"
+    {{/java8}}
+    {{#threetenbp}}
+    compile "com.github.joschi.jackson:jackson-datatype-threetenbp:$jackson_version"
+    {{/threetenbp}}
+    testCompile "junit:junit:$junit_version"
+    testCompile "io.vertx:vertx-unit:$vertx_version"
+}

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/pom.mustache

@@ -0,0 +1,259 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>{{groupId}}</groupId>
+  <artifactId>{{artifactId}}</artifactId>
+  <packaging>jar</packaging>
+  <name>{{artifactId}}</name>
+  <version>{{artifactVersion}}</version>
+  <url>{{artifactUrl}}</url>
+  <description>{{artifactDescription}}</description>
+  <scm>
+    <connection>{{scmConnection}}</connection>
+    <developerConnection>{{scmDeveloperConnection}}</developerConnection>
+    <url>{{scmUrl}}</url>
+  </scm>
+  <prerequisites>
+    <maven>2.2.0</maven>
+  </prerequisites>
+
+  <licenses>
+    <license>
+      <name>{{licenseName}}</name>
+      <url>{{licenseUrl}}</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <name>{{developerName}}</name>
+      <email>{{developerEmail}}</email>
+      <organization>{{developerOrganization}}</organization>
+      <organizationUrl>{{developerOrganizationUrl}}</organizationUrl>
+    </developer>
+  </developers>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>2.12</version>
+        <configuration>
+          <systemProperties>
+            <property>
+              <name>loggerPath</name>
+              <value>conf/log4j.properties</value>
+            </property>
+          </systemProperties>
+          <argLine>-Xms512m -Xmx1500m</argLine>
+          <parallel>methods</parallel>
+          <forkMode>pertest</forkMode>
+        </configuration>
+      </plugin>
+      <plugin>
+        <artifactId>maven-dependency-plugin</artifactId>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>copy-dependencies</goal>
+            </goals>
+            <configuration>
+              <outputDirectory>${project.build.directory}/lib</outputDirectory>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+
+      <!-- attach test jar -->
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.6</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>jar</goal>
+              <goal>test-jar</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>build-helper-maven-plugin</artifactId>
+        <version>3.0.0</version>
+        <executions>
+          <execution>
+            <id>add_sources</id>
+            <phase>generate-sources</phase>
+            <goals>
+              <goal>add-source</goal>
+            </goals>
+            <configuration>
+              <sources>
+                <source>src/main/java</source>
+              </sources>
+            </configuration>
+          </execution>
+          <execution>
+            <id>add_test_sources</id>
+            <phase>generate-test-sources</phase>
+            <goals>
+              <goal>add-test-source</goal>
+            </goals>
+            <configuration>
+              <sources>
+                <source>src/test/java</source>
+              </sources>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.6.1</version>
+        <configuration>
+          <source>1.8</source>
+          <target>1.8</target>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>2.10.4</version>
+        <executions>
+          <execution>
+            <id>attach-javadocs</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-source-plugin</artifactId>
+        <version>2.2.1</version>
+        <executions>
+          <execution>
+            <id>attach-sources</id>
+            <goals>
+              <goal>jar-no-fork</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+
+  <profiles>
+    <profile>
+      <id>sign-artifacts</id>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-gpg-plugin</artifactId>
+            <version>1.5</version>
+            <executions>
+              <execution>
+                <id>sign-artifacts</id>
+                <phase>verify</phase>
+                <goals>
+                  <goal>sign</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
+  </profiles>
+
+  <dependencies>
+    <dependency>
+      <groupId>io.swagger</groupId>
+      <artifactId>swagger-annotations</artifactId>
+      <version>${swagger-core-version}</version>
+    </dependency>
+
+    <!-- Vertx -->
+    <dependency>
+        <groupId>io.vertx</groupId>
+        <artifactId>vertx-rx-java</artifactId>
+        <version>${vertx-version}</version>
+    </dependency>
+    <dependency>
+        <groupId>io.vertx</groupId>
+        <artifactId>vertx-web-client</artifactId>
+        <version>${vertx-version}</version>
+    </dependency>
+
+      <!-- JSON processing: jackson -->
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-core</artifactId>
+      <version>${jackson-version}</version>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-annotations</artifactId>
+      <version>${jackson-version}</version>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>${jackson-version}</version>
+    </dependency>
+    {{#joda}}
+    <dependency>
+      <groupId>com.fasterxml.jackson.datatype</groupId>
+      <artifactId>jackson-datatype-joda</artifactId>
+      <version>${jackson-version}</version>
+    </dependency>
+    {{/joda}}
+    {{#java8}}
+    <dependency>
+      <groupId>com.fasterxml.jackson.datatype</groupId>
+      <artifactId>jackson-datatype-jsr310</artifactId>
+      <version>${jackson-version}</version>
+    </dependency>
+    {{/java8}}
+    {{#threetenbp}}
+    <dependency>
+      <groupId>com.github.joschi.jackson</groupId>
+      <artifactId>jackson-datatype-threetenbp</artifactId>
+      <version>${jackson-version}</version>
+    </dependency>
+    {{/threetenbp}}
+
+    <!-- test dependencies -->
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>${junit-version}</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+        <groupId>io.vertx</groupId>
+        <artifactId>vertx-unit</artifactId>
+        <version>${vertx-version}</version>
+        <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <vertx-version>3.4.2</vertx-version>
+    <swagger-core-version>1.5.16</swagger-core-version>
+    <jackson-version>{{^threetenbp}}2.8.9{{/threetenbp}}{{#threetenbp}}2.6.4{{/threetenbp}}</jackson-version>
+    <junit-version>4.12</junit-version>
+  </properties>
+</project>

modules/swagger-codegen/src/main/resources/Java/libraries/vertx/rxApiImpl.mustache

@@ -0,0 +1,58 @@
+package {{package}}.rxjava;
+
+{{#imports}}import {{import}};
+{{/imports}}
+
+import java.util.*;
+
+import rx.Single;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+
+{{>generatedAnnotation}}
+{{#operations}}
+public class {{classname}} {
+
+	private final {{package}}.{{classname}} delegate;
+
+	public {{classname}}({{package}}.{{classname}} delegate) {
+	    this.delegate = delegate;
+    }
+
+	public {{package}}.{{classname}} getDelegate() {
+	    return delegate;
+	}
+
+    {{#operation}}
+    /**
+     * {{summary}}
+     * {{notes}}
+     {{#allParams}}
+     * @param {{paramName}} {{description}}{{#required}} (required){{/required}}{{^required}} (optional{{#defaultValue}}, default to {{{.}}}{{/defaultValue}}){{/required}}
+     {{/allParams}}
+     * @param resultHandler Asynchronous result handler
+     */
+    public void {{operationId}}({{#allParams}}{{{dataType}}} {{paramName}}, {{/allParams}}Handler<AsyncResult<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}Void{{/returnType}}>> resultHandler) {
+        delegate.{{operationId}}({{#allParams}}{{paramName}}, {{/allParams}}resultHandler);
+    }
+
+    /**
+     * {{summary}}
+     * {{notes}}
+     {{#allParams}}
+     * @param {{paramName}} {{description}}{{#required}} (required){{/required}}{{^required}} (optional{{#defaultValue}}, default to {{{.}}}{{/defaultValue}}){{/required}}
+     {{/allParams}}
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}Void{{/returnType}}> rx{{operationIdCamelCase}}({{#allParams}}{{{dataType}}} {{paramName}}{{#hasMore}}, {{/hasMore}}{{/allParams}}) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.{{operationId}}({{#allParams}}{{paramName}}, {{/allParams}}fut);
+        }));
+    }
+    {{/operation}}
+
+    public static {{classname}} newInstance({{package}}.{{classname}} arg) {
+        return arg != null ? new {{classname}}(arg) : null;
+    }
+}
+{{/operations}}

samples/client/petstore/java/vertx/.gitignore

@@ -0,0 +1,21 @@
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+# exclude jar for gradle wrapper
+!gradle/wrapper/*.jar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+# build files
+**/target
+target
+.gradle
+build

samples/client/petstore/java/vertx/.swagger-codegen-ignore

@@ -0,0 +1,23 @@
+# Swagger Codegen Ignore
+# Generated by swagger-codegen https://github.com/swagger-api/swagger-codegen
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell Swagger Codgen to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md

samples/client/petstore/java/vertx/.swagger-codegen/VERSION

@@ -0,0 +1 @@
+2.3.0-SNAPSHOT

samples/client/petstore/java/vertx/.travis.yml

@@ -0,0 +1,17 @@
+#
+# Generated by: https://github.com/swagger-api/swagger-codegen.git
+#
+language: java
+jdk:
+  - oraclejdk8
+  - oraclejdk7
+before_install:
+  # ensure gradlew has proper permission
+  - chmod a+x ./gradlew
+script:
+  # test using maven
+  - mvn test
+  # uncomment below to test using gradle
+  # - gradle test
+  # uncomment below to test using sbt 
+  # - sbt test

samples/client/petstore/java/vertx/README.md

@@ -0,0 +1,196 @@
+# swagger-petstore-vertx
+
+## Requirements
+
+Building the API client library requires [Maven](https://maven.apache.org/) to be installed.
+
+## Installation
+
+To install the API client library to your local Maven repository, simply execute:
+
+```shell
+mvn install
+```
+
+To deploy it to a remote Maven repository instead, configure the settings of the repository and execute:
+
+```shell
+mvn deploy
+```
+
+Refer to the [official documentation](https://maven.apache.org/plugins/maven-deploy-plugin/usage.html) for more information.
+
+### Maven users
+
+Add this dependency to your project's POM:
+
+```xml
+<dependency>
+    <groupId>io.swagger</groupId>
+    <artifactId>swagger-petstore-vertx</artifactId>
+    <version>1.0.0</version>
+    <scope>compile</scope>
+</dependency>
+```
+
+### Gradle users
+
+Add this dependency to your project's build file:
+
+```groovy
+compile "io.swagger:swagger-petstore-vertx:1.0.0"
+```
+
+### Others
+
+At first generate the JAR by executing:
+
+    mvn package
+
+Then manually install the following JARs:
+
+* target/swagger-petstore-vertx-1.0.0.jar
+* target/lib/*.jar
+
+## Getting Started
+
+Please follow the [installation](#installation) instruction and execute the following Java code:
+
+```java
+
+import io.swagger.client.*;
+import io.swagger.client.auth.*;
+import io.swagger.client.model.*;
+import io.swagger.client.api.FakeApi;
+
+import java.io.File;
+import java.util.*;
+
+public class FakeApiExample {
+
+    public static void main(String[] args) {
+        
+        FakeApi apiInstance = new FakeApi();
+        Boolean body = true; // Boolean | Input boolean as post body
+        try {
+            Boolean result = apiInstance.fakeOuterBooleanSerialize(body);
+            System.out.println(result);
+        } catch (ApiException e) {
+            System.err.println("Exception when calling FakeApi#fakeOuterBooleanSerialize");
+            e.printStackTrace();
+        }
+    }
+}
+
+```
+
+## Documentation for API Endpoints
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Class | Method | HTTP request | Description
+------------ | ------------- | ------------- | -------------
+*FakeApi* | [**fakeOuterBooleanSerialize**](docs/FakeApi.md#fakeOuterBooleanSerialize) | **POST** /fake/outer/boolean | 
+*FakeApi* | [**fakeOuterCompositeSerialize**](docs/FakeApi.md#fakeOuterCompositeSerialize) | **POST** /fake/outer/composite | 
+*FakeApi* | [**fakeOuterNumberSerialize**](docs/FakeApi.md#fakeOuterNumberSerialize) | **POST** /fake/outer/number | 
+*FakeApi* | [**fakeOuterStringSerialize**](docs/FakeApi.md#fakeOuterStringSerialize) | **POST** /fake/outer/string | 
+*FakeApi* | [**testClientModel**](docs/FakeApi.md#testClientModel) | **PATCH** /fake | To test \&quot;client\&quot; model
+*FakeApi* | [**testEndpointParameters**](docs/FakeApi.md#testEndpointParameters) | **POST** /fake | Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+*FakeApi* | [**testEnumParameters**](docs/FakeApi.md#testEnumParameters) | **GET** /fake | To test enum parameters
+*FakeApi* | [**testJsonFormData**](docs/FakeApi.md#testJsonFormData) | **GET** /fake/jsonFormData | test json serialization of form data
+*FakeClassnameTags123Api* | [**testClassname**](docs/FakeClassnameTags123Api.md#testClassname) | **PATCH** /fake_classname_test | To test class name in snake case
+*PetApi* | [**addPet**](docs/PetApi.md#addPet) | **POST** /pet | Add a new pet to the store
+*PetApi* | [**deletePet**](docs/PetApi.md#deletePet) | **DELETE** /pet/{petId} | Deletes a pet
+*PetApi* | [**findPetsByStatus**](docs/PetApi.md#findPetsByStatus) | **GET** /pet/findByStatus | Finds Pets by status
+*PetApi* | [**findPetsByTags**](docs/PetApi.md#findPetsByTags) | **GET** /pet/findByTags | Finds Pets by tags
+*PetApi* | [**getPetById**](docs/PetApi.md#getPetById) | **GET** /pet/{petId} | Find pet by ID
+*PetApi* | [**updatePet**](docs/PetApi.md#updatePet) | **PUT** /pet | Update an existing pet
+*PetApi* | [**updatePetWithForm**](docs/PetApi.md#updatePetWithForm) | **POST** /pet/{petId} | Updates a pet in the store with form data
+*PetApi* | [**uploadFile**](docs/PetApi.md#uploadFile) | **POST** /pet/{petId}/uploadImage | uploads an image
+*StoreApi* | [**deleteOrder**](docs/StoreApi.md#deleteOrder) | **DELETE** /store/order/{order_id} | Delete purchase order by ID
+*StoreApi* | [**getInventory**](docs/StoreApi.md#getInventory) | **GET** /store/inventory | Returns pet inventories by status
+*StoreApi* | [**getOrderById**](docs/StoreApi.md#getOrderById) | **GET** /store/order/{order_id} | Find purchase order by ID
+*StoreApi* | [**placeOrder**](docs/StoreApi.md#placeOrder) | **POST** /store/order | Place an order for a pet
+*UserApi* | [**createUser**](docs/UserApi.md#createUser) | **POST** /user | Create user
+*UserApi* | [**createUsersWithArrayInput**](docs/UserApi.md#createUsersWithArrayInput) | **POST** /user/createWithArray | Creates list of users with given input array
+*UserApi* | [**createUsersWithListInput**](docs/UserApi.md#createUsersWithListInput) | **POST** /user/createWithList | Creates list of users with given input array
+*UserApi* | [**deleteUser**](docs/UserApi.md#deleteUser) | **DELETE** /user/{username} | Delete user
+*UserApi* | [**getUserByName**](docs/UserApi.md#getUserByName) | **GET** /user/{username} | Get user by user name
+*UserApi* | [**loginUser**](docs/UserApi.md#loginUser) | **GET** /user/login | Logs user into the system
+*UserApi* | [**logoutUser**](docs/UserApi.md#logoutUser) | **GET** /user/logout | Logs out current logged in user session
+*UserApi* | [**updateUser**](docs/UserApi.md#updateUser) | **PUT** /user/{username} | Updated user
+
+
+## Documentation for Models
+
+ - [AdditionalPropertiesClass](docs/AdditionalPropertiesClass.md)
+ - [Animal](docs/Animal.md)
+ - [AnimalFarm](docs/AnimalFarm.md)
+ - [ArrayOfArrayOfNumberOnly](docs/ArrayOfArrayOfNumberOnly.md)
+ - [ArrayOfNumberOnly](docs/ArrayOfNumberOnly.md)
+ - [ArrayTest](docs/ArrayTest.md)
+ - [Capitalization](docs/Capitalization.md)
+ - [Category](docs/Category.md)
+ - [ClassModel](docs/ClassModel.md)
+ - [Client](docs/Client.md)
+ - [EnumArrays](docs/EnumArrays.md)
+ - [EnumClass](docs/EnumClass.md)
+ - [EnumTest](docs/EnumTest.md)
+ - [FormatTest](docs/FormatTest.md)
+ - [HasOnlyReadOnly](docs/HasOnlyReadOnly.md)
+ - [MapTest](docs/MapTest.md)
+ - [MixedPropertiesAndAdditionalPropertiesClass](docs/MixedPropertiesAndAdditionalPropertiesClass.md)
+ - [Model200Response](docs/Model200Response.md)
+ - [ModelApiResponse](docs/ModelApiResponse.md)
+ - [ModelReturn](docs/ModelReturn.md)
+ - [Name](docs/Name.md)
+ - [NumberOnly](docs/NumberOnly.md)
+ - [Order](docs/Order.md)
+ - [OuterComposite](docs/OuterComposite.md)
+ - [OuterEnum](docs/OuterEnum.md)
+ - [Pet](docs/Pet.md)
+ - [ReadOnlyFirst](docs/ReadOnlyFirst.md)
+ - [SpecialModelName](docs/SpecialModelName.md)
+ - [Tag](docs/Tag.md)
+ - [User](docs/User.md)
+ - [Cat](docs/Cat.md)
+ - [Dog](docs/Dog.md)
+
+
+## Documentation for Authorization
+
+Authentication schemes defined for the API:
+### api_key
+
+- **Type**: API key
+- **API key parameter name**: api_key
+- **Location**: HTTP header
+
+### api_key_query
+
+- **Type**: API key
+- **API key parameter name**: api_key_query
+- **Location**: URL query string
+
+### http_basic_test
+
+- **Type**: HTTP basic authentication
+
+### petstore_auth
+
+- **Type**: OAuth
+- **Flow**: implicit
+- **Authorization URL**: http://petstore.swagger.io/api/oauth/dialog
+- **Scopes**: 
+  - write:pets: modify pets in your account
+  - read:pets: read your pets
+
+
+## Recommendation
+
+It's recommended to create an instance of `ApiClient` per thread in a multithreaded environment to avoid any potential issues.
+
+## Author
+
+apiteam@swagger.io
+

samples/client/petstore/java/vertx/build.gradle

@@ -0,0 +1,46 @@
+apply plugin: 'idea'
+apply plugin: 'eclipse'
+
+group = 'io.swagger'
+version = '1.0.0'
+
+repositories {
+    jcenter()
+}
+
+apply plugin: 'java'
+apply plugin: 'maven'
+
+sourceCompatibility = JavaVersion.VERSION_1_8
+targetCompatibility = JavaVersion.VERSION_1_8
+
+install {
+    repositories.mavenInstaller {
+        pom.artifactId = 'swagger-petstore-vertx'
+    }
+}
+
+task execute(type:JavaExec) {
+   main = System.getProperty('mainClass')
+   classpath = sourceSets.main.runtimeClasspath
+}
+
+ext {
+    swagger_annotations_version = "1.5.15"
+    jackson_version = "2.6.4"
+    vertx_version = "3.4.2"
+    junit_version = "4.12"
+}
+
+dependencies {
+    compile "io.swagger:swagger-annotations:$swagger_annotations_version"
+    compile "io.vertx:vertx-web-client:$vertx_version"
+    compile "io.vertx:vertx-rx-java:$vertx_version"
+    compile "com.fasterxml.jackson.core:jackson-core:$jackson_version"
+    compile "com.fasterxml.jackson.core:jackson-annotations:$jackson_version"
+    compile "com.fasterxml.jackson.core:jackson-databind:$jackson_version"
+    compile "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:$jackson_version"
+    compile "com.github.joschi.jackson:jackson-datatype-threetenbp:$jackson_version"
+    testCompile "junit:junit:$junit_version"
+    testCompile "io.vertx:vertx-unit:$vertx_version"
+}

samples/client/petstore/java/vertx/docs/AdditionalPropertiesClass.md

@@ -0,0 +1,11 @@
+
+# AdditionalPropertiesClass
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**mapProperty** | **Map<String, String>** |  |  [optional]
+**mapOfMapProperty** | [**Map<String, Map<String, String>>**](Map.md) |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/Animal.md

@@ -0,0 +1,11 @@
+
+# Animal
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**className** | **String** |  | 
+**color** | **String** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/AnimalFarm.md

@@ -0,0 +1,9 @@
+
+# AnimalFarm
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+
+
+

samples/client/petstore/java/vertx/docs/ArrayOfArrayOfNumberOnly.md

@@ -0,0 +1,10 @@
+
+# ArrayOfArrayOfNumberOnly
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**arrayArrayNumber** | [**List<List<BigDecimal>>**](List.md) |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/ArrayOfNumberOnly.md

@@ -0,0 +1,10 @@
+
+# ArrayOfNumberOnly
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**arrayNumber** | [**List<BigDecimal>**](BigDecimal.md) |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/ArrayTest.md

@@ -0,0 +1,12 @@
+
+# ArrayTest
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**arrayOfString** | **List<String>** |  |  [optional]
+**arrayArrayOfInteger** | [**List<List<Long>>**](List.md) |  |  [optional]
+**arrayArrayOfModel** | [**List<List<ReadOnlyFirst>>**](List.md) |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/Capitalization.md

@@ -0,0 +1,15 @@
+
+# Capitalization
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**smallCamel** | **String** |  |  [optional]
+**capitalCamel** | **String** |  |  [optional]
+**smallSnake** | **String** |  |  [optional]
+**capitalSnake** | **String** |  |  [optional]
+**scAETHFlowPoints** | **String** |  |  [optional]
+**ATT_NAME** | **String** | Name of the pet  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/Cat.md

@@ -0,0 +1,10 @@
+
+# Cat
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**declawed** | **Boolean** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/Category.md

@@ -0,0 +1,11 @@
+
+# Category
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **Long** |  |  [optional]
+**name** | **String** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/ClassModel.md

@@ -0,0 +1,10 @@
+
+# ClassModel
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**propertyClass** | **String** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/Client.md

@@ -0,0 +1,10 @@
+
+# Client
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**client** | **String** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/Dog.md

@@ -0,0 +1,10 @@
+
+# Dog
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**breed** | **String** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/EnumArrays.md

@@ -0,0 +1,27 @@
+
+# EnumArrays
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**justSymbol** | [**JustSymbolEnum**](#JustSymbolEnum) |  |  [optional]
+**arrayEnum** | [**List<ArrayEnumEnum>**](#List<ArrayEnumEnum>) |  |  [optional]
+
+
+<a name="JustSymbolEnum"></a>
+## Enum: JustSymbolEnum
+Name | Value
+---- | -----
+GREATER_THAN_OR_EQUAL_TO | &quot;&gt;&#x3D;&quot;
+DOLLAR | &quot;$&quot;
+
+
+<a name="List<ArrayEnumEnum>"></a>
+## Enum: List&lt;ArrayEnumEnum&gt;
+Name | Value
+---- | -----
+FISH | &quot;fish&quot;
+CRAB | &quot;crab&quot;
+
+
+

samples/client/petstore/java/vertx/docs/EnumClass.md

@@ -0,0 +1,14 @@
+
+# EnumClass
+
+## Enum
+
+
+* `_ABC` (value: `"_abc"`)
+
+* `_EFG` (value: `"-efg"`)
+
+* `_XYZ_` (value: `"(xyz)"`)
+
+
+

samples/client/petstore/java/vertx/docs/EnumTest.md

@@ -0,0 +1,38 @@
+
+# EnumTest
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**enumString** | [**EnumStringEnum**](#EnumStringEnum) |  |  [optional]
+**enumInteger** | [**EnumIntegerEnum**](#EnumIntegerEnum) |  |  [optional]
+**enumNumber** | [**EnumNumberEnum**](#EnumNumberEnum) |  |  [optional]
+**outerEnum** | [**OuterEnum**](OuterEnum.md) |  |  [optional]
+
+
+<a name="EnumStringEnum"></a>
+## Enum: EnumStringEnum
+Name | Value
+---- | -----
+UPPER | &quot;UPPER&quot;
+LOWER | &quot;lower&quot;
+EMPTY | &quot;&quot;
+
+
+<a name="EnumIntegerEnum"></a>
+## Enum: EnumIntegerEnum
+Name | Value
+---- | -----
+NUMBER_1 | 1
+NUMBER_MINUS_1 | -1
+
+
+<a name="EnumNumberEnum"></a>
+## Enum: EnumNumberEnum
+Name | Value
+---- | -----
+NUMBER_1_DOT_1 | 1.1
+NUMBER_MINUS_1_DOT_2 | -1.2
+
+
+

samples/client/petstore/java/vertx/docs/FakeApi.md

@@ -0,0 +1,424 @@
+# FakeApi
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**fakeOuterBooleanSerialize**](FakeApi.md#fakeOuterBooleanSerialize) | **POST** /fake/outer/boolean | 
+[**fakeOuterCompositeSerialize**](FakeApi.md#fakeOuterCompositeSerialize) | **POST** /fake/outer/composite | 
+[**fakeOuterNumberSerialize**](FakeApi.md#fakeOuterNumberSerialize) | **POST** /fake/outer/number | 
+[**fakeOuterStringSerialize**](FakeApi.md#fakeOuterStringSerialize) | **POST** /fake/outer/string | 
+[**testClientModel**](FakeApi.md#testClientModel) | **PATCH** /fake | To test \"client\" model
+[**testEndpointParameters**](FakeApi.md#testEndpointParameters) | **POST** /fake | Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+[**testEnumParameters**](FakeApi.md#testEnumParameters) | **GET** /fake | To test enum parameters
+[**testJsonFormData**](FakeApi.md#testJsonFormData) | **GET** /fake/jsonFormData | test json serialization of form data
+
+
+<a name="fakeOuterBooleanSerialize"></a>
+# **fakeOuterBooleanSerialize**
+> Boolean fakeOuterBooleanSerialize(body)
+
+
+
+Test serialization of outer boolean types
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.FakeApi;
+
+
+FakeApi apiInstance = new FakeApi();
+Boolean body = true; // Boolean | Input boolean as post body
+try {
+    Boolean result = apiInstance.fakeOuterBooleanSerialize(body);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling FakeApi#fakeOuterBooleanSerialize");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | [**Boolean**](Boolean.md)| Input boolean as post body | [optional]
+
+### Return type
+
+**Boolean**
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+<a name="fakeOuterCompositeSerialize"></a>
+# **fakeOuterCompositeSerialize**
+> OuterComposite fakeOuterCompositeSerialize(body)
+
+
+
+Test serialization of object with outer number type
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.FakeApi;
+
+
+FakeApi apiInstance = new FakeApi();
+OuterComposite body = new OuterComposite(); // OuterComposite | Input composite as post body
+try {
+    OuterComposite result = apiInstance.fakeOuterCompositeSerialize(body);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling FakeApi#fakeOuterCompositeSerialize");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | [**OuterComposite**](OuterComposite.md)| Input composite as post body | [optional]
+
+### Return type
+
+[**OuterComposite**](OuterComposite.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+<a name="fakeOuterNumberSerialize"></a>
+# **fakeOuterNumberSerialize**
+> BigDecimal fakeOuterNumberSerialize(body)
+
+
+
+Test serialization of outer number types
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.FakeApi;
+
+
+FakeApi apiInstance = new FakeApi();
+BigDecimal body = new BigDecimal(); // BigDecimal | Input number as post body
+try {
+    BigDecimal result = apiInstance.fakeOuterNumberSerialize(body);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling FakeApi#fakeOuterNumberSerialize");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | [**BigDecimal**](BigDecimal.md)| Input number as post body | [optional]
+
+### Return type
+
+[**BigDecimal**](BigDecimal.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+<a name="fakeOuterStringSerialize"></a>
+# **fakeOuterStringSerialize**
+> String fakeOuterStringSerialize(body)
+
+
+
+Test serialization of outer string types
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.FakeApi;
+
+
+FakeApi apiInstance = new FakeApi();
+String body = "body_example"; // String | Input string as post body
+try {
+    String result = apiInstance.fakeOuterStringSerialize(body);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling FakeApi#fakeOuterStringSerialize");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | [**String**](String.md)| Input string as post body | [optional]
+
+### Return type
+
+**String**
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+<a name="testClientModel"></a>
+# **testClientModel**
+> Client testClientModel(body)
+
+To test \&quot;client\&quot; model
+
+To test \&quot;client\&quot; model
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.FakeApi;
+
+
+FakeApi apiInstance = new FakeApi();
+Client body = new Client(); // Client | client model
+try {
+    Client result = apiInstance.testClientModel(body);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling FakeApi#testClientModel");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | [**Client**](Client.md)| client model |
+
+### Return type
+
+[**Client**](Client.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+<a name="testEndpointParameters"></a>
+# **testEndpointParameters**
+> testEndpointParameters(number, _double, patternWithoutDelimiter, _byte, integer, int32, int64, _float, string, binary, date, dateTime, password, paramCallback)
+
+Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+
+Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiClient;
+//import io.swagger.client.ApiException;
+//import io.swagger.client.Configuration;
+//import io.swagger.client.auth.*;
+//import io.swagger.client.api.FakeApi;
+
+ApiClient defaultClient = Configuration.getDefaultApiClient();
+
+// Configure HTTP basic authorization: http_basic_test
+HttpBasicAuth http_basic_test = (HttpBasicAuth) defaultClient.getAuthentication("http_basic_test");
+http_basic_test.setUsername("YOUR USERNAME");
+http_basic_test.setPassword("YOUR PASSWORD");
+
+FakeApi apiInstance = new FakeApi();
+BigDecimal number = new BigDecimal(); // BigDecimal | None
+Double _double = 3.4D; // Double | None
+String patternWithoutDelimiter = "patternWithoutDelimiter_example"; // String | None
+byte[] _byte = _byte_example; // byte[] | None
+Integer integer = 56; // Integer | None
+Integer int32 = 56; // Integer | None
+Long int64 = 789L; // Long | None
+Float _float = 3.4F; // Float | None
+String string = "string_example"; // String | None
+byte[] binary = B; // byte[] | None
+LocalDate date = new LocalDate(); // LocalDate | None
+OffsetDateTime dateTime = new OffsetDateTime(); // OffsetDateTime | None
+String password = "password_example"; // String | None
+String paramCallback = "paramCallback_example"; // String | None
+try {
+    apiInstance.testEndpointParameters(number, _double, patternWithoutDelimiter, _byte, integer, int32, int64, _float, string, binary, date, dateTime, password, paramCallback);
+} catch (ApiException e) {
+    System.err.println("Exception when calling FakeApi#testEndpointParameters");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **number** | **BigDecimal**| None |
+ **_double** | **Double**| None |
+ **patternWithoutDelimiter** | **String**| None |
+ **_byte** | **byte[]**| None |
+ **integer** | **Integer**| None | [optional]
+ **int32** | **Integer**| None | [optional]
+ **int64** | **Long**| None | [optional]
+ **_float** | **Float**| None | [optional]
+ **string** | **String**| None | [optional]
+ **binary** | **byte[]**| None | [optional]
+ **date** | **LocalDate**| None | [optional]
+ **dateTime** | **OffsetDateTime**| None | [optional]
+ **password** | **String**| None | [optional]
+ **paramCallback** | **String**| None | [optional]
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+[http_basic_test](../README.md#http_basic_test)
+
+### HTTP request headers
+
+ - **Content-Type**: application/xml; charset=utf-8, application/json; charset=utf-8
+ - **Accept**: application/xml; charset=utf-8, application/json; charset=utf-8
+
+<a name="testEnumParameters"></a>
+# **testEnumParameters**
+> testEnumParameters(enumFormStringArray, enumFormString, enumHeaderStringArray, enumHeaderString, enumQueryStringArray, enumQueryString, enumQueryInteger, enumQueryDouble)
+
+To test enum parameters
+
+To test enum parameters
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.FakeApi;
+
+
+FakeApi apiInstance = new FakeApi();
+List<String> enumFormStringArray = Arrays.asList("enumFormStringArray_example"); // List<String> | Form parameter enum test (string array)
+String enumFormString = "-efg"; // String | Form parameter enum test (string)
+List<String> enumHeaderStringArray = Arrays.asList("enumHeaderStringArray_example"); // List<String> | Header parameter enum test (string array)
+String enumHeaderString = "-efg"; // String | Header parameter enum test (string)
+List<String> enumQueryStringArray = Arrays.asList("enumQueryStringArray_example"); // List<String> | Query parameter enum test (string array)
+String enumQueryString = "-efg"; // String | Query parameter enum test (string)
+Integer enumQueryInteger = 56; // Integer | Query parameter enum test (double)
+Double enumQueryDouble = 3.4D; // Double | Query parameter enum test (double)
+try {
+    apiInstance.testEnumParameters(enumFormStringArray, enumFormString, enumHeaderStringArray, enumHeaderString, enumQueryStringArray, enumQueryString, enumQueryInteger, enumQueryDouble);
+} catch (ApiException e) {
+    System.err.println("Exception when calling FakeApi#testEnumParameters");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **enumFormStringArray** | [**List&lt;String&gt;**](String.md)| Form parameter enum test (string array) | [optional] [enum: >, $]
+ **enumFormString** | **String**| Form parameter enum test (string) | [optional] [default to -efg] [enum: _abc, -efg, (xyz)]
+ **enumHeaderStringArray** | [**List&lt;String&gt;**](String.md)| Header parameter enum test (string array) | [optional] [enum: >, $]
+ **enumHeaderString** | **String**| Header parameter enum test (string) | [optional] [default to -efg] [enum: _abc, -efg, (xyz)]
+ **enumQueryStringArray** | [**List&lt;String&gt;**](String.md)| Query parameter enum test (string array) | [optional] [enum: >, $]
+ **enumQueryString** | **String**| Query parameter enum test (string) | [optional] [default to -efg] [enum: _abc, -efg, (xyz)]
+ **enumQueryInteger** | **Integer**| Query parameter enum test (double) | [optional] [enum: 1, -2]
+ **enumQueryDouble** | **Double**| Query parameter enum test (double) | [optional] [enum: 1.1, -1.2]
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: */*
+ - **Accept**: */*
+
+<a name="testJsonFormData"></a>
+# **testJsonFormData**
+> testJsonFormData(param, param2)
+
+test json serialization of form data
+
+
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.FakeApi;
+
+
+FakeApi apiInstance = new FakeApi();
+String param = "param_example"; // String | field1
+String param2 = "param2_example"; // String | field2
+try {
+    apiInstance.testJsonFormData(param, param2);
+} catch (ApiException e) {
+    System.err.println("Exception when calling FakeApi#testJsonFormData");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **param** | **String**| field1 |
+ **param2** | **String**| field2 |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: Not defined
+

samples/client/petstore/java/vertx/docs/FakeClassnameTags123Api.md

@@ -0,0 +1,62 @@
+# FakeClassnameTags123Api
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**testClassname**](FakeClassnameTags123Api.md#testClassname) | **PATCH** /fake_classname_test | To test class name in snake case
+
+
+<a name="testClassname"></a>
+# **testClassname**
+> Client testClassname(body)
+
+To test class name in snake case
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiClient;
+//import io.swagger.client.ApiException;
+//import io.swagger.client.Configuration;
+//import io.swagger.client.auth.*;
+//import io.swagger.client.api.FakeClassnameTags123Api;
+
+ApiClient defaultClient = Configuration.getDefaultApiClient();
+
+// Configure API key authorization: api_key_query
+ApiKeyAuth api_key_query = (ApiKeyAuth) defaultClient.getAuthentication("api_key_query");
+api_key_query.setApiKey("YOUR API KEY");
+// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
+//api_key_query.setApiKeyPrefix("Token");
+
+FakeClassnameTags123Api apiInstance = new FakeClassnameTags123Api();
+Client body = new Client(); // Client | client model
+try {
+    Client result = apiInstance.testClassname(body);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling FakeClassnameTags123Api#testClassname");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | [**Client**](Client.md)| client model |
+
+### Return type
+
+[**Client**](Client.md)
+
+### Authorization
+
+[api_key_query](../README.md#api_key_query)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+

samples/client/petstore/java/vertx/docs/FormatTest.md

@@ -0,0 +1,22 @@
+
+# FormatTest
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**integer** | **Integer** |  |  [optional]
+**int32** | **Integer** |  |  [optional]
+**int64** | **Long** |  |  [optional]
+**number** | [**BigDecimal**](BigDecimal.md) |  | 
+**_float** | **Float** |  |  [optional]
+**_double** | **Double** |  |  [optional]
+**string** | **String** |  |  [optional]
+**_byte** | **byte[]** |  | 
+**binary** | **byte[]** |  |  [optional]
+**date** | [**LocalDate**](LocalDate.md) |  | 
+**dateTime** | [**OffsetDateTime**](OffsetDateTime.md) |  |  [optional]
+**uuid** | [**UUID**](UUID.md) |  |  [optional]
+**password** | **String** |  | 
+
+
+

samples/client/petstore/java/vertx/docs/HasOnlyReadOnly.md

@@ -0,0 +1,11 @@
+
+# HasOnlyReadOnly
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**bar** | **String** |  |  [optional]
+**foo** | **String** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/MapTest.md

@@ -0,0 +1,19 @@
+
+# MapTest
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**mapMapOfString** | [**Map<String, Map<String, String>>**](Map.md) |  |  [optional]
+**mapOfEnumString** | [**Map<String, InnerEnum>**](#Map<String, InnerEnum>) |  |  [optional]
+
+
+<a name="Map<String, InnerEnum>"></a>
+## Enum: Map&lt;String, InnerEnum&gt;
+Name | Value
+---- | -----
+UPPER | &quot;UPPER&quot;
+LOWER | &quot;lower&quot;
+
+
+

samples/client/petstore/java/vertx/docs/MixedPropertiesAndAdditionalPropertiesClass.md

@@ -0,0 +1,12 @@
+
+# MixedPropertiesAndAdditionalPropertiesClass
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**uuid** | [**UUID**](UUID.md) |  |  [optional]
+**dateTime** | [**OffsetDateTime**](OffsetDateTime.md) |  |  [optional]
+**map** | [**Map<String, Animal>**](Animal.md) |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/Model200Response.md

@@ -0,0 +1,11 @@
+
+# Model200Response
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**name** | **Integer** |  |  [optional]
+**propertyClass** | **String** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/ModelApiResponse.md

@@ -0,0 +1,12 @@
+
+# ModelApiResponse
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**code** | **Integer** |  |  [optional]
+**type** | **String** |  |  [optional]
+**message** | **String** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/ModelReturn.md

@@ -0,0 +1,10 @@
+
+# ModelReturn
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**_return** | **Integer** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/Name.md

@@ -0,0 +1,13 @@
+
+# Name
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**name** | **Integer** |  | 
+**snakeCase** | **Integer** |  |  [optional]
+**property** | **String** |  |  [optional]
+**_123Number** | **Integer** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/NumberOnly.md

@@ -0,0 +1,10 @@
+
+# NumberOnly
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**justNumber** | [**BigDecimal**](BigDecimal.md) |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/Order.md

@@ -0,0 +1,24 @@
+
+# Order
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **Long** |  |  [optional]
+**petId** | **Long** |  |  [optional]
+**quantity** | **Integer** |  |  [optional]
+**shipDate** | [**OffsetDateTime**](OffsetDateTime.md) |  |  [optional]
+**status** | [**StatusEnum**](#StatusEnum) | Order Status |  [optional]
+**complete** | **Boolean** |  |  [optional]
+
+
+<a name="StatusEnum"></a>
+## Enum: StatusEnum
+Name | Value
+---- | -----
+PLACED | &quot;placed&quot;
+APPROVED | &quot;approved&quot;
+DELIVERED | &quot;delivered&quot;
+
+
+

samples/client/petstore/java/vertx/docs/OuterComposite.md

@@ -0,0 +1,12 @@
+
+# OuterComposite
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**myNumber** | [**BigDecimal**](BigDecimal.md) |  |  [optional]
+**myString** | **String** |  |  [optional]
+**myBoolean** | **Boolean** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/OuterEnum.md

@@ -0,0 +1,14 @@
+
+# OuterEnum
+
+## Enum
+
+
+* `PLACED` (value: `"placed"`)
+
+* `APPROVED` (value: `"approved"`)
+
+* `DELIVERED` (value: `"delivered"`)
+
+
+

samples/client/petstore/java/vertx/docs/Pet.md

@@ -0,0 +1,24 @@
+
+# Pet
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **Long** |  |  [optional]
+**category** | [**Category**](Category.md) |  |  [optional]
+**name** | **String** |  | 
+**photoUrls** | **List<String>** |  | 
+**tags** | [**List<Tag>**](Tag.md) |  |  [optional]
+**status** | [**StatusEnum**](#StatusEnum) | pet status in the store |  [optional]
+
+
+<a name="StatusEnum"></a>
+## Enum: StatusEnum
+Name | Value
+---- | -----
+AVAILABLE | &quot;available&quot;
+PENDING | &quot;pending&quot;
+SOLD | &quot;sold&quot;
+
+
+

samples/client/petstore/java/vertx/docs/PetApi.md

@@ -0,0 +1,448 @@
+# PetApi
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**addPet**](PetApi.md#addPet) | **POST** /pet | Add a new pet to the store
+[**deletePet**](PetApi.md#deletePet) | **DELETE** /pet/{petId} | Deletes a pet
+[**findPetsByStatus**](PetApi.md#findPetsByStatus) | **GET** /pet/findByStatus | Finds Pets by status
+[**findPetsByTags**](PetApi.md#findPetsByTags) | **GET** /pet/findByTags | Finds Pets by tags
+[**getPetById**](PetApi.md#getPetById) | **GET** /pet/{petId} | Find pet by ID
+[**updatePet**](PetApi.md#updatePet) | **PUT** /pet | Update an existing pet
+[**updatePetWithForm**](PetApi.md#updatePetWithForm) | **POST** /pet/{petId} | Updates a pet in the store with form data
+[**uploadFile**](PetApi.md#uploadFile) | **POST** /pet/{petId}/uploadImage | uploads an image
+
+
+<a name="addPet"></a>
+# **addPet**
+> addPet(body)
+
+Add a new pet to the store
+
+
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiClient;
+//import io.swagger.client.ApiException;
+//import io.swagger.client.Configuration;
+//import io.swagger.client.auth.*;
+//import io.swagger.client.api.PetApi;
+
+ApiClient defaultClient = Configuration.getDefaultApiClient();
+
+// Configure OAuth2 access token for authorization: petstore_auth
+OAuth petstore_auth = (OAuth) defaultClient.getAuthentication("petstore_auth");
+petstore_auth.setAccessToken("YOUR ACCESS TOKEN");
+
+PetApi apiInstance = new PetApi();
+Pet body = new Pet(); // Pet | Pet object that needs to be added to the store
+try {
+    apiInstance.addPet(body);
+} catch (ApiException e) {
+    System.err.println("Exception when calling PetApi#addPet");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | [**Pet**](Pet.md)| Pet object that needs to be added to the store |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json, application/xml
+ - **Accept**: application/xml, application/json
+
+<a name="deletePet"></a>
+# **deletePet**
+> deletePet(petId, apiKey)
+
+Deletes a pet
+
+
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiClient;
+//import io.swagger.client.ApiException;
+//import io.swagger.client.Configuration;
+//import io.swagger.client.auth.*;
+//import io.swagger.client.api.PetApi;
+
+ApiClient defaultClient = Configuration.getDefaultApiClient();
+
+// Configure OAuth2 access token for authorization: petstore_auth
+OAuth petstore_auth = (OAuth) defaultClient.getAuthentication("petstore_auth");
+petstore_auth.setAccessToken("YOUR ACCESS TOKEN");
+
+PetApi apiInstance = new PetApi();
+Long petId = 789L; // Long | Pet id to delete
+String apiKey = "apiKey_example"; // String | 
+try {
+    apiInstance.deletePet(petId, apiKey);
+} catch (ApiException e) {
+    System.err.println("Exception when calling PetApi#deletePet");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **petId** | **Long**| Pet id to delete |
+ **apiKey** | **String**|  | [optional]
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="findPetsByStatus"></a>
+# **findPetsByStatus**
+> List&lt;Pet&gt; findPetsByStatus(status)
+
+Finds Pets by status
+
+Multiple status values can be provided with comma separated strings
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiClient;
+//import io.swagger.client.ApiException;
+//import io.swagger.client.Configuration;
+//import io.swagger.client.auth.*;
+//import io.swagger.client.api.PetApi;
+
+ApiClient defaultClient = Configuration.getDefaultApiClient();
+
+// Configure OAuth2 access token for authorization: petstore_auth
+OAuth petstore_auth = (OAuth) defaultClient.getAuthentication("petstore_auth");
+petstore_auth.setAccessToken("YOUR ACCESS TOKEN");
+
+PetApi apiInstance = new PetApi();
+List<String> status = Arrays.asList("status_example"); // List<String> | Status values that need to be considered for filter
+try {
+    List<Pet> result = apiInstance.findPetsByStatus(status);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling PetApi#findPetsByStatus");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **status** | [**List&lt;String&gt;**](String.md)| Status values that need to be considered for filter | [enum: available, pending, sold]
+
+### Return type
+
+[**List&lt;Pet&gt;**](Pet.md)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="findPetsByTags"></a>
+# **findPetsByTags**
+> List&lt;Pet&gt; findPetsByTags(tags)
+
+Finds Pets by tags
+
+Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiClient;
+//import io.swagger.client.ApiException;
+//import io.swagger.client.Configuration;
+//import io.swagger.client.auth.*;
+//import io.swagger.client.api.PetApi;
+
+ApiClient defaultClient = Configuration.getDefaultApiClient();
+
+// Configure OAuth2 access token for authorization: petstore_auth
+OAuth petstore_auth = (OAuth) defaultClient.getAuthentication("petstore_auth");
+petstore_auth.setAccessToken("YOUR ACCESS TOKEN");
+
+PetApi apiInstance = new PetApi();
+List<String> tags = Arrays.asList("tags_example"); // List<String> | Tags to filter by
+try {
+    List<Pet> result = apiInstance.findPetsByTags(tags);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling PetApi#findPetsByTags");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **tags** | [**List&lt;String&gt;**](String.md)| Tags to filter by |
+
+### Return type
+
+[**List&lt;Pet&gt;**](Pet.md)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="getPetById"></a>
+# **getPetById**
+> Pet getPetById(petId)
+
+Find pet by ID
+
+Returns a single pet
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiClient;
+//import io.swagger.client.ApiException;
+//import io.swagger.client.Configuration;
+//import io.swagger.client.auth.*;
+//import io.swagger.client.api.PetApi;
+
+ApiClient defaultClient = Configuration.getDefaultApiClient();
+
+// Configure API key authorization: api_key
+ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
+api_key.setApiKey("YOUR API KEY");
+// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
+//api_key.setApiKeyPrefix("Token");
+
+PetApi apiInstance = new PetApi();
+Long petId = 789L; // Long | ID of pet to return
+try {
+    Pet result = apiInstance.getPetById(petId);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling PetApi#getPetById");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **petId** | **Long**| ID of pet to return |
+
+### Return type
+
+[**Pet**](Pet.md)
+
+### Authorization
+
+[api_key](../README.md#api_key)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="updatePet"></a>
+# **updatePet**
+> updatePet(body)
+
+Update an existing pet
+
+
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiClient;
+//import io.swagger.client.ApiException;
+//import io.swagger.client.Configuration;
+//import io.swagger.client.auth.*;
+//import io.swagger.client.api.PetApi;
+
+ApiClient defaultClient = Configuration.getDefaultApiClient();
+
+// Configure OAuth2 access token for authorization: petstore_auth
+OAuth petstore_auth = (OAuth) defaultClient.getAuthentication("petstore_auth");
+petstore_auth.setAccessToken("YOUR ACCESS TOKEN");
+
+PetApi apiInstance = new PetApi();
+Pet body = new Pet(); // Pet | Pet object that needs to be added to the store
+try {
+    apiInstance.updatePet(body);
+} catch (ApiException e) {
+    System.err.println("Exception when calling PetApi#updatePet");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | [**Pet**](Pet.md)| Pet object that needs to be added to the store |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json, application/xml
+ - **Accept**: application/xml, application/json
+
+<a name="updatePetWithForm"></a>
+# **updatePetWithForm**
+> updatePetWithForm(petId, name, status)
+
+Updates a pet in the store with form data
+
+
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiClient;
+//import io.swagger.client.ApiException;
+//import io.swagger.client.Configuration;
+//import io.swagger.client.auth.*;
+//import io.swagger.client.api.PetApi;
+
+ApiClient defaultClient = Configuration.getDefaultApiClient();
+
+// Configure OAuth2 access token for authorization: petstore_auth
+OAuth petstore_auth = (OAuth) defaultClient.getAuthentication("petstore_auth");
+petstore_auth.setAccessToken("YOUR ACCESS TOKEN");
+
+PetApi apiInstance = new PetApi();
+Long petId = 789L; // Long | ID of pet that needs to be updated
+String name = "name_example"; // String | Updated name of the pet
+String status = "status_example"; // String | Updated status of the pet
+try {
+    apiInstance.updatePetWithForm(petId, name, status);
+} catch (ApiException e) {
+    System.err.println("Exception when calling PetApi#updatePetWithForm");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **petId** | **Long**| ID of pet that needs to be updated |
+ **name** | **String**| Updated name of the pet | [optional]
+ **status** | **String**| Updated status of the pet | [optional]
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: application/x-www-form-urlencoded
+ - **Accept**: application/xml, application/json
+
+<a name="uploadFile"></a>
+# **uploadFile**
+> ModelApiResponse uploadFile(petId, additionalMetadata, file)
+
+uploads an image
+
+
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiClient;
+//import io.swagger.client.ApiException;
+//import io.swagger.client.Configuration;
+//import io.swagger.client.auth.*;
+//import io.swagger.client.api.PetApi;
+
+ApiClient defaultClient = Configuration.getDefaultApiClient();
+
+// Configure OAuth2 access token for authorization: petstore_auth
+OAuth petstore_auth = (OAuth) defaultClient.getAuthentication("petstore_auth");
+petstore_auth.setAccessToken("YOUR ACCESS TOKEN");
+
+PetApi apiInstance = new PetApi();
+Long petId = 789L; // Long | ID of pet to update
+String additionalMetadata = "additionalMetadata_example"; // String | Additional data to pass to server
+AsyncFile file = new AsyncFile(); // AsyncFile | file to upload
+try {
+    ModelApiResponse result = apiInstance.uploadFile(petId, additionalMetadata, file);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling PetApi#uploadFile");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **petId** | **Long**| ID of pet to update |
+ **additionalMetadata** | **String**| Additional data to pass to server | [optional]
+ **file** | **AsyncFile**| file to upload | [optional]
+
+### Return type
+
+[**ModelApiResponse**](ModelApiResponse.md)
+
+### Authorization
+
+[petstore_auth](../README.md#petstore_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: multipart/form-data
+ - **Accept**: application/json
+

samples/client/petstore/java/vertx/docs/ReadOnlyFirst.md

@@ -0,0 +1,11 @@
+
+# ReadOnlyFirst
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**bar** | **String** |  |  [optional]
+**baz** | **String** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/SpecialModelName.md

@@ -0,0 +1,10 @@
+
+# SpecialModelName
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**specialPropertyName** | **Long** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/StoreApi.md

@@ -0,0 +1,197 @@
+# StoreApi
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**deleteOrder**](StoreApi.md#deleteOrder) | **DELETE** /store/order/{order_id} | Delete purchase order by ID
+[**getInventory**](StoreApi.md#getInventory) | **GET** /store/inventory | Returns pet inventories by status
+[**getOrderById**](StoreApi.md#getOrderById) | **GET** /store/order/{order_id} | Find purchase order by ID
+[**placeOrder**](StoreApi.md#placeOrder) | **POST** /store/order | Place an order for a pet
+
+
+<a name="deleteOrder"></a>
+# **deleteOrder**
+> deleteOrder(orderId)
+
+Delete purchase order by ID
+
+For valid response try integer IDs with value &lt; 1000. Anything above 1000 or nonintegers will generate API errors
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.StoreApi;
+
+
+StoreApi apiInstance = new StoreApi();
+String orderId = "orderId_example"; // String | ID of the order that needs to be deleted
+try {
+    apiInstance.deleteOrder(orderId);
+} catch (ApiException e) {
+    System.err.println("Exception when calling StoreApi#deleteOrder");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **orderId** | **String**| ID of the order that needs to be deleted |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="getInventory"></a>
+# **getInventory**
+> Map&lt;String, Integer&gt; getInventory()
+
+Returns pet inventories by status
+
+Returns a map of status codes to quantities
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiClient;
+//import io.swagger.client.ApiException;
+//import io.swagger.client.Configuration;
+//import io.swagger.client.auth.*;
+//import io.swagger.client.api.StoreApi;
+
+ApiClient defaultClient = Configuration.getDefaultApiClient();
+
+// Configure API key authorization: api_key
+ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
+api_key.setApiKey("YOUR API KEY");
+// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
+//api_key.setApiKeyPrefix("Token");
+
+StoreApi apiInstance = new StoreApi();
+try {
+    Map<String, Integer> result = apiInstance.getInventory();
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling StoreApi#getInventory");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+This endpoint does not need any parameter.
+
+### Return type
+
+[**Map&lt;String, Integer&gt;**](Map.md)
+
+### Authorization
+
+[api_key](../README.md#api_key)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+<a name="getOrderById"></a>
+# **getOrderById**
+> Order getOrderById(orderId)
+
+Find purchase order by ID
+
+For valid response try integer IDs with value &lt;&#x3D; 5 or &gt; 10. Other values will generated exceptions
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.StoreApi;
+
+
+StoreApi apiInstance = new StoreApi();
+Long orderId = 789L; // Long | ID of pet that needs to be fetched
+try {
+    Order result = apiInstance.getOrderById(orderId);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling StoreApi#getOrderById");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **orderId** | **Long**| ID of pet that needs to be fetched |
+
+### Return type
+
+[**Order**](Order.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="placeOrder"></a>
+# **placeOrder**
+> Order placeOrder(body)
+
+Place an order for a pet
+
+
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.StoreApi;
+
+
+StoreApi apiInstance = new StoreApi();
+Order body = new Order(); // Order | order placed for purchasing the pet
+try {
+    Order result = apiInstance.placeOrder(body);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling StoreApi#placeOrder");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | [**Order**](Order.md)| order placed for purchasing the pet |
+
+### Return type
+
+[**Order**](Order.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+

samples/client/petstore/java/vertx/docs/Tag.md

@@ -0,0 +1,11 @@
+
+# Tag
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **Long** |  |  [optional]
+**name** | **String** |  |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/User.md

@@ -0,0 +1,17 @@
+
+# User
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **Long** |  |  [optional]
+**username** | **String** |  |  [optional]
+**firstName** | **String** |  |  [optional]
+**lastName** | **String** |  |  [optional]
+**email** | **String** |  |  [optional]
+**password** | **String** |  |  [optional]
+**phone** | **String** |  |  [optional]
+**userStatus** | **Integer** | User Status |  [optional]
+
+
+

samples/client/petstore/java/vertx/docs/UserApi.md

@@ -0,0 +1,370 @@
+# UserApi
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**createUser**](UserApi.md#createUser) | **POST** /user | Create user
+[**createUsersWithArrayInput**](UserApi.md#createUsersWithArrayInput) | **POST** /user/createWithArray | Creates list of users with given input array
+[**createUsersWithListInput**](UserApi.md#createUsersWithListInput) | **POST** /user/createWithList | Creates list of users with given input array
+[**deleteUser**](UserApi.md#deleteUser) | **DELETE** /user/{username} | Delete user
+[**getUserByName**](UserApi.md#getUserByName) | **GET** /user/{username} | Get user by user name
+[**loginUser**](UserApi.md#loginUser) | **GET** /user/login | Logs user into the system
+[**logoutUser**](UserApi.md#logoutUser) | **GET** /user/logout | Logs out current logged in user session
+[**updateUser**](UserApi.md#updateUser) | **PUT** /user/{username} | Updated user
+
+
+<a name="createUser"></a>
+# **createUser**
+> createUser(body)
+
+Create user
+
+This can only be done by the logged in user.
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.UserApi;
+
+
+UserApi apiInstance = new UserApi();
+User body = new User(); // User | Created user object
+try {
+    apiInstance.createUser(body);
+} catch (ApiException e) {
+    System.err.println("Exception when calling UserApi#createUser");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | [**User**](User.md)| Created user object |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="createUsersWithArrayInput"></a>
+# **createUsersWithArrayInput**
+> createUsersWithArrayInput(body)
+
+Creates list of users with given input array
+
+
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.UserApi;
+
+
+UserApi apiInstance = new UserApi();
+List<User> body = Arrays.asList(new User()); // List<User> | List of user object
+try {
+    apiInstance.createUsersWithArrayInput(body);
+} catch (ApiException e) {
+    System.err.println("Exception when calling UserApi#createUsersWithArrayInput");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | [**List&lt;User&gt;**](User.md)| List of user object |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="createUsersWithListInput"></a>
+# **createUsersWithListInput**
+> createUsersWithListInput(body)
+
+Creates list of users with given input array
+
+
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.UserApi;
+
+
+UserApi apiInstance = new UserApi();
+List<User> body = Arrays.asList(new User()); // List<User> | List of user object
+try {
+    apiInstance.createUsersWithListInput(body);
+} catch (ApiException e) {
+    System.err.println("Exception when calling UserApi#createUsersWithListInput");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **body** | [**List&lt;User&gt;**](User.md)| List of user object |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="deleteUser"></a>
+# **deleteUser**
+> deleteUser(username)
+
+Delete user
+
+This can only be done by the logged in user.
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.UserApi;
+
+
+UserApi apiInstance = new UserApi();
+String username = "username_example"; // String | The name that needs to be deleted
+try {
+    apiInstance.deleteUser(username);
+} catch (ApiException e) {
+    System.err.println("Exception when calling UserApi#deleteUser");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **username** | **String**| The name that needs to be deleted |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="getUserByName"></a>
+# **getUserByName**
+> User getUserByName(username)
+
+Get user by user name
+
+
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.UserApi;
+
+
+UserApi apiInstance = new UserApi();
+String username = "username_example"; // String | The name that needs to be fetched. Use user1 for testing. 
+try {
+    User result = apiInstance.getUserByName(username);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling UserApi#getUserByName");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **username** | **String**| The name that needs to be fetched. Use user1 for testing.  |
+
+### Return type
+
+[**User**](User.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="loginUser"></a>
+# **loginUser**
+> String loginUser(username, password)
+
+Logs user into the system
+
+
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.UserApi;
+
+
+UserApi apiInstance = new UserApi();
+String username = "username_example"; // String | The user name for login
+String password = "password_example"; // String | The password for login in clear text
+try {
+    String result = apiInstance.loginUser(username, password);
+    System.out.println(result);
+} catch (ApiException e) {
+    System.err.println("Exception when calling UserApi#loginUser");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **username** | **String**| The user name for login |
+ **password** | **String**| The password for login in clear text |
+
+### Return type
+
+**String**
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="logoutUser"></a>
+# **logoutUser**
+> logoutUser()
+
+Logs out current logged in user session
+
+
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.UserApi;
+
+
+UserApi apiInstance = new UserApi();
+try {
+    apiInstance.logoutUser();
+} catch (ApiException e) {
+    System.err.println("Exception when calling UserApi#logoutUser");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+This endpoint does not need any parameter.
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+<a name="updateUser"></a>
+# **updateUser**
+> updateUser(username, body)
+
+Updated user
+
+This can only be done by the logged in user.
+
+### Example
+```java
+// Import classes:
+//import io.swagger.client.ApiException;
+//import io.swagger.client.api.UserApi;
+
+
+UserApi apiInstance = new UserApi();
+String username = "username_example"; // String | name that need to be deleted
+User body = new User(); // User | Updated user object
+try {
+    apiInstance.updateUser(username, body);
+} catch (ApiException e) {
+    System.err.println("Exception when calling UserApi#updateUser");
+    e.printStackTrace();
+}
+```
+
+### Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **username** | **String**| name that need to be deleted |
+ **body** | [**User**](User.md)| Updated user object |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+

samples/client/petstore/java/vertx/git_push.sh

@@ -0,0 +1,52 @@
+#!/bin/sh
+# ref: https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/
+#
+# Usage example: /bin/sh ./git_push.sh wing328 swagger-petstore-perl "minor update"
+
+git_user_id=$1
+git_repo_id=$2
+release_note=$3
+
+if [ "$git_user_id" = "" ]; then
+    git_user_id="GIT_USER_ID"
+    echo "[INFO] No command line input provided. Set \$git_user_id to $git_user_id"
+fi
+
+if [ "$git_repo_id" = "" ]; then
+    git_repo_id="GIT_REPO_ID"
+    echo "[INFO] No command line input provided. Set \$git_repo_id to $git_repo_id"
+fi
+
+if [ "$release_note" = "" ]; then
+    release_note="Minor update"
+    echo "[INFO] No command line input provided. Set \$release_note to $release_note"
+fi
+
+# Initialize the local directory as a Git repository
+git init
+
+# Adds the files in the local repository and stages them for commit.
+git add .
+
+# Commits the tracked changes and prepares them to be pushed to a remote repository. 
+git commit -m "$release_note"
+
+# Sets the new remote
+git_remote=`git remote`
+if [ "$git_remote" = "" ]; then # git remote not defined
+
+    if [ "$GIT_TOKEN" = "" ]; then
+        echo "[INFO] \$GIT_TOKEN (environment variable) is not set. Using the git crediential in your environment."
+        git remote add origin https://github.com/${git_user_id}/${git_repo_id}.git
+    else
+        git remote add origin https://${git_user_id}:${GIT_TOKEN}@github.com/${git_user_id}/${git_repo_id}.git
+    fi
+
+fi
+
+git pull origin master
+
+# Pushes (Forces) the changes in the local repository up to the remote repository
+echo "Git pushing to https://github.com/${git_user_id}/${git_repo_id}.git"
+git push origin master 2>&1 | grep -v 'To https'
+

samples/client/petstore/java/vertx/gradle.properties

@@ -0,0 +1,2 @@
+# Uncomment to build for Android
+#target = android

samples/client/petstore/java/vertx/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Tue May 17 23:08:05 CST 2016
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.6-bin.zip

samples/client/petstore/java/vertx/gradlew

@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

samples/client/petstore/java/vertx/gradlew.bat

@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

samples/client/petstore/java/vertx/pom.xml

@@ -0,0 +1,248 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>io.swagger</groupId>
+  <artifactId>swagger-petstore-vertx</artifactId>
+  <packaging>jar</packaging>
+  <name>swagger-petstore-vertx</name>
+  <version>1.0.0</version>
+  <url>https://github.com/swagger-api/swagger-codegen</url>
+  <description>Swagger Java</description>
+  <scm>
+    <connection>scm:git:git@github.com:swagger-api/swagger-codegen.git</connection>
+    <developerConnection>scm:git:git@github.com:swagger-api/swagger-codegen.git</developerConnection>
+    <url>https://github.com/swagger-api/swagger-codegen</url>
+  </scm>
+  <prerequisites>
+    <maven>2.2.0</maven>
+  </prerequisites>
+
+  <licenses>
+    <license>
+      <name>Unlicense</name>
+      <url>http://www.apache.org/licenses/LICENSE-2.0.html</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <name>Swagger</name>
+      <email>apiteam@swagger.io</email>
+      <organization>Swagger</organization>
+      <organizationUrl>http://swagger.io</organizationUrl>
+    </developer>
+  </developers>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>2.12</version>
+        <configuration>
+          <systemProperties>
+            <property>
+              <name>loggerPath</name>
+              <value>conf/log4j.properties</value>
+            </property>
+          </systemProperties>
+          <argLine>-Xms512m -Xmx1500m</argLine>
+          <parallel>methods</parallel>
+          <forkMode>pertest</forkMode>
+        </configuration>
+      </plugin>
+      <plugin>
+        <artifactId>maven-dependency-plugin</artifactId>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>copy-dependencies</goal>
+            </goals>
+            <configuration>
+              <outputDirectory>${project.build.directory}/lib</outputDirectory>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+
+      <!-- attach test jar -->
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.6</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>jar</goal>
+              <goal>test-jar</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>build-helper-maven-plugin</artifactId>
+        <version>3.0.0</version>
+        <executions>
+          <execution>
+            <id>add_sources</id>
+            <phase>generate-sources</phase>
+            <goals>
+              <goal>add-source</goal>
+            </goals>
+            <configuration>
+              <sources>
+                <source>src/main/java</source>
+              </sources>
+            </configuration>
+          </execution>
+          <execution>
+            <id>add_test_sources</id>
+            <phase>generate-test-sources</phase>
+            <goals>
+              <goal>add-test-source</goal>
+            </goals>
+            <configuration>
+              <sources>
+                <source>src/test/java</source>
+              </sources>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.6.1</version>
+        <configuration>
+          <source>1.8</source>
+          <target>1.8</target>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>2.10.4</version>
+        <executions>
+          <execution>
+            <id>attach-javadocs</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-source-plugin</artifactId>
+        <version>2.2.1</version>
+        <executions>
+          <execution>
+            <id>attach-sources</id>
+            <goals>
+              <goal>jar-no-fork</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+
+  <profiles>
+    <profile>
+      <id>sign-artifacts</id>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-gpg-plugin</artifactId>
+            <version>1.5</version>
+            <executions>
+              <execution>
+                <id>sign-artifacts</id>
+                <phase>verify</phase>
+                <goals>
+                  <goal>sign</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
+  </profiles>
+
+  <dependencies>
+    <dependency>
+      <groupId>io.swagger</groupId>
+      <artifactId>swagger-annotations</artifactId>
+      <version>${swagger-core-version}</version>
+    </dependency>
+
+    <!-- Vertx -->
+    <dependency>
+        <groupId>io.vertx</groupId>
+        <artifactId>vertx-rx-java</artifactId>
+        <version>${vertx-version}</version>
+    </dependency>
+    <dependency>
+        <groupId>io.vertx</groupId>
+        <artifactId>vertx-web-client</artifactId>
+        <version>${vertx-version}</version>
+    </dependency>
+
+      <!-- JSON processing: jackson -->
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-core</artifactId>
+      <version>${jackson-version}</version>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-annotations</artifactId>
+      <version>${jackson-version}</version>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>${jackson-version}</version>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.datatype</groupId>
+      <artifactId>jackson-datatype-jsr310</artifactId>
+      <version>${jackson-version}</version>
+    </dependency>
+    <dependency>
+      <groupId>com.github.joschi.jackson</groupId>
+      <artifactId>jackson-datatype-threetenbp</artifactId>
+      <version>${jackson-version}</version>
+    </dependency>
+
+    <!-- test dependencies -->
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>${junit-version}</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+        <groupId>io.vertx</groupId>
+        <artifactId>vertx-unit</artifactId>
+        <version>${vertx-version}</version>
+        <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <vertx-version>3.4.2</vertx-version>
+    <swagger-core-version>1.5.16</swagger-core-version>
+    <jackson-version>2.6.4</jackson-version>
+    <junit-version>4.12</junit-version>
+  </properties>
+</project>

samples/client/petstore/java/vertx/settings.gradle

@@ -0,0 +1 @@
+rootProject.name = "swagger-petstore-vertx"

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/ApiClient.java

@@ -0,0 +1,600 @@
+package io.swagger.client;
+
+import io.swagger.client.auth.Authentication;
+import io.swagger.client.auth.HttpBasicAuth;
+import io.swagger.client.auth.ApiKeyAuth;
+import io.swagger.client.auth.OAuth;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import io.vertx.core.*;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.file.AsyncFile;
+import io.vertx.core.file.FileSystem;
+import io.vertx.core.file.OpenOptions;
+import io.vertx.core.http.HttpHeaders;
+import io.vertx.core.http.HttpMethod;
+import io.vertx.core.json.Json;
+import io.vertx.core.json.JsonObject;
+import io.vertx.ext.web.client.HttpRequest;
+import io.vertx.ext.web.client.HttpResponse;
+import io.vertx.ext.web.client.WebClient;
+import io.vertx.ext.web.client.WebClientOptions;
+
+import java.text.DateFormat;
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static java.util.stream.Collectors.toMap;
+
+
+public class ApiClient {
+
+    private static final Pattern CONTENT_DISPOSITION_PATTERN = Pattern.compile("filename=['\"]?([^'\"\\s]+)['\"]?");
+    private static final OpenOptions FILE_DOWNLOAD_OPTIONS = new OpenOptions().setCreate(true).setTruncateExisting(true);
+
+    private final Vertx vertx;
+
+    private MultiMap defaultHeaders = MultiMap.caseInsensitiveMultiMap();
+    private Map<String, Authentication> authentications;
+    private WebClient webClient;
+    private String basePath = "http://petstore.swagger.io:80/v2";
+    private DateFormat dateFormat;
+    private ObjectMapper objectMapper;
+    private String downloadsDir = "";
+
+    public ApiClient(Vertx vertx, JsonObject config) {
+        Objects.requireNonNull(vertx, "Vertx must not be null");
+        Objects.requireNonNull(config, "Config must not be null");
+
+        this.vertx = vertx;
+
+        // Use RFC3339 format for date and datetime.
+        // See http://xml2rfc.ietf.org/public/rfc/html/rfc3339.html#anchor14
+        this.dateFormat = new RFC3339DateFormat();
+
+        // Use UTC as the default time zone.
+        this.dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+
+        // Build object mapper
+        this.objectMapper = new ObjectMapper();
+        this.objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+        this.objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        this.objectMapper.configure(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE, false);
+        this.objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+        this.objectMapper.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
+        this.objectMapper.enable(DeserializationFeature.READ_ENUMS_USING_TO_STRING);
+        this.objectMapper.registerModule(new JavaTimeModule());
+        this.objectMapper.setDateFormat(dateFormat);
+
+        // Setup authentications (key: authentication name, value: authentication).
+        this.authentications = new HashMap<>();
+        authentications.put("api_key", new ApiKeyAuth("header", "api_key"));
+        authentications.put("api_key_query", new ApiKeyAuth("query", "api_key_query"));
+        authentications.put("http_basic_test", new HttpBasicAuth());
+        authentications.put("petstore_auth", new OAuth());
+        // Prevent the authentications from being modified.
+        this.authentications = Collections.unmodifiableMap(authentications);
+
+        // Configurations
+        this.basePath = config.getString("basePath", this.basePath);
+        this.downloadsDir = config.getString("downloadsDir", this.downloadsDir);
+
+        // Build WebClient
+        this.webClient = buildWebClient(vertx, config);
+    }
+
+    public Vertx getVertx() {
+        return vertx;
+    }
+
+    public ObjectMapper getObjectMapper() {
+        return objectMapper;
+    }
+
+    public ApiClient setObjectMapper(ObjectMapper objectMapper) {
+        this.objectMapper = objectMapper;
+        return this;
+    }
+
+    public WebClient getWebClient() {
+        return webClient;
+    }
+
+    public ApiClient setWebClient(WebClient webClient) {
+        this.webClient = webClient;
+        return this;
+    }
+
+    public String getBasePath() {
+        return basePath;
+    }
+
+    public ApiClient setBasePath(String basePath) {
+        this.basePath = basePath;
+        return this;
+    }
+
+    public String getDownloadsDir() {
+        return downloadsDir;
+    }
+
+    public ApiClient setDownloadsDir(String downloadsDir) {
+        this.downloadsDir = downloadsDir;
+        return this;
+    }
+
+    public MultiMap getDefaultHeaders() {
+        return defaultHeaders;
+    }
+
+    public ApiClient addDefaultHeader(String key, String value) {
+        defaultHeaders.add(key, value);
+        return this;
+    }
+
+    /**
+     * Get authentications (key: authentication name, value: authentication).
+     *
+     * @return Map of authentication object
+     */
+    public Map<String, Authentication> getAuthentications() {
+        return authentications;
+    }
+
+    /**
+     * Get authentication for the given name.
+     *
+     * @param authName The authentication name
+     * @return The authentication, null if not found
+     */
+    public Authentication getAuthentication(String authName) {
+        return authentications.get(authName);
+    }
+
+    /**
+     * Helper method to set username for the first HTTP basic authentication.
+     *
+     * @param username Username
+     */
+    public ApiClient setUsername(String username) {
+        for (Authentication auth : authentications.values()) {
+            if (auth instanceof HttpBasicAuth) {
+                ((HttpBasicAuth) auth).setUsername(username);
+                return this;
+            }
+        }
+        throw new RuntimeException("No HTTP basic authentication configured!");
+    }
+
+    /**
+     * Helper method to set password for the first HTTP basic authentication.
+     *
+     * @param password Password
+     */
+    public ApiClient setPassword(String password) {
+        for (Authentication auth : authentications.values()) {
+            if (auth instanceof HttpBasicAuth) {
+                ((HttpBasicAuth) auth).setPassword(password);
+                return this;
+            }
+        }
+        throw new RuntimeException("No HTTP basic authentication configured!");
+    }
+
+    /**
+     * Helper method to set API key value for the first API key authentication.
+     *
+     * @param apiKey API key
+     */
+    public ApiClient setApiKey(String apiKey) {
+        for (Authentication auth : authentications.values()) {
+            if (auth instanceof ApiKeyAuth) {
+                ((ApiKeyAuth) auth).setApiKey(apiKey);
+                return this;
+            }
+        }
+        throw new RuntimeException("No API key authentication configured!");
+    }
+
+    /**
+     * Helper method to set API key prefix for the first API key authentication.
+     *
+     * @param apiKeyPrefix API key prefix
+     */
+    public ApiClient setApiKeyPrefix(String apiKeyPrefix) {
+        for (Authentication auth : authentications.values()) {
+            if (auth instanceof ApiKeyAuth) {
+                ((ApiKeyAuth) auth).setApiKeyPrefix(apiKeyPrefix);
+                return this;
+            }
+        }
+        throw new RuntimeException("No API key authentication configured!");
+    }
+
+    /**
+     * Helper method to set access token for the first OAuth2 authentication.
+     *
+     * @param accessToken Access token
+     */
+    public ApiClient setAccessToken(String accessToken) {
+        for (Authentication auth : authentications.values()) {
+            if (auth instanceof OAuth) {
+                ((OAuth) auth).setAccessToken(accessToken);
+                return this;
+            }
+        }
+        throw new RuntimeException("No OAuth2 authentication configured!");
+    }
+
+    /**
+     * Format the given Date object into string.
+     *
+     * @param date Date
+     * @return Date in string format
+     */
+    public String formatDate(Date date) {
+        return dateFormat.format(date);
+    }
+
+    /**
+     * Format the given parameter object into string.
+     *
+     * @param param Object
+     * @return Object in string format
+     */
+    public String parameterToString(Object param) {
+        if (param == null) {
+            return "";
+        } else if (param instanceof Date) {
+            return formatDate((Date) param);
+        } else if (param instanceof Collection) {
+            StringBuilder b = new StringBuilder();
+            for (Object o : (Collection) param) {
+                if (b.length() > 0) {
+                    b.append(',');
+                }
+                b.append(String.valueOf(o));
+            }
+            return b.toString();
+        } else {
+            return String.valueOf(param);
+        }
+    }
+
+    /*
+     * Format to {@code Pair} objects.
+     * @param collectionFormat Collection format
+     * @param name Name
+     * @param value Value
+     * @return List of pairs
+     */
+    public List<Pair> parameterToPairs(String collectionFormat, String name, Object value) {
+        List<Pair> params = new ArrayList<Pair>();
+
+        // preconditions
+        if (name == null || name.isEmpty() || value == null) return params;
+
+        Collection valueCollection;
+        if (value instanceof Collection) {
+            valueCollection = (Collection) value;
+        } else {
+            params.add(new Pair(name, parameterToString(value)));
+            return params;
+        }
+
+        if (valueCollection.isEmpty()) {
+            return params;
+        }
+
+        // get the collection format (default: csv)
+        String format = (collectionFormat == null || collectionFormat.isEmpty() ? "csv" : collectionFormat);
+
+        // create the params based on the collection format
+        if ("multi".equals(format)) {
+            for (Object item : valueCollection) {
+                params.add(new Pair(name, parameterToString(item)));
+            }
+            return params;
+        }
+
+        String delimiter = ",";
+        if ("csv".equals(format)) {
+            delimiter = ",";
+        } else if ("ssv".equals(format)) {
+            delimiter = " ";
+        } else if ("tsv".equals(format)) {
+            delimiter = "\t";
+        } else if ("pipes".equals(format)) {
+            delimiter = "|";
+        }
+
+        StringBuilder sb = new StringBuilder();
+        for (Object item : valueCollection) {
+            sb.append(delimiter);
+            sb.append(parameterToString(item));
+        }
+
+        params.add(new Pair(name, sb.substring(1)));
+
+        return params;
+    }
+
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     * application/json
+     * application/json; charset=UTF8
+     * APPLICATION/JSON
+     * application/vnd.company+json
+     *
+     * @param mime MIME
+     * @return True if the MIME type is JSON
+     */
+    private boolean isJsonMime(String mime) {
+        String jsonMime = "(?i)^(application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(;.*)?$";
+        return mime != null && (mime.matches(jsonMime) || mime.equalsIgnoreCase("application/json-patch+json"));
+    }
+
+    /**
+     * Select the Accept header's value from the given accepts array:
+     * if JSON exists in the given array, use it;
+     * otherwise use all of them (joining into a string)
+     *
+     * @param accepts The accepts array to select from
+     * @return The Accept header to use. If the given array is empty,
+     * null will be returned (not to set the Accept header explicitly).
+     */
+    protected String selectHeaderAccept(String[] accepts) {
+        if (accepts.length == 0) {
+            return null;
+        }
+        for (String accept : accepts) {
+            if (isJsonMime(accept)) {
+                return accept;
+            }
+        }
+        return StringUtil.join(accepts, ",");
+    }
+
+    /**
+     * Select the Content-Type header's value from the given array:
+     * if JSON exists in the given array, use it;
+     * otherwise use the first one of the array.
+     *
+     * @param contentTypes The Content-Type array to select from
+     * @return The Content-Type header to use. If the given array is empty,
+     * JSON will be used.
+     */
+    protected String selectHeaderContentType(String[] contentTypes) {
+        if (contentTypes.length == 0) {
+            return "application/json";
+        }
+        for (String contentType : contentTypes) {
+            if (isJsonMime(contentType)) {
+                return contentType;
+            }
+        }
+        return contentTypes[0];
+    }
+
+    public void sendBody(HttpRequest<Buffer> request,
+                         Handler<AsyncResult<HttpResponse<Buffer>>> responseHandler,
+                         Object body) {
+        if (body instanceof byte[]) {
+            Buffer buffer = Buffer.buffer((byte[]) body);
+            request.sendBuffer(buffer, responseHandler);
+        } else if (body instanceof AsyncFile) {
+            AsyncFile file = (AsyncFile) body;
+            request.sendStream(file, responseHandler);
+        } else {
+            request.sendJson(body, responseHandler);
+        }
+    }
+
+    /**
+     * Invoke API by sending HTTP request with the given options.
+     *
+     * @param <T> Type
+     * @param path The sub-path of the HTTP URL
+     * @param method The request method, one of "GET", "POST", "PUT", "HEAD" and "DELETE"
+     * @param queryParams The query parameters
+     * @param body The request body object
+     * @param headerParams The header parameters
+     * @param formParams The form parameters
+     * @param accepts The request's Accept headers
+     * @param contentTypes The request's Content-Type headers
+     * @param authNames The authentications to apply
+     * @param returnType The return type into which to deserialize the response
+     * @param resultHandler The asynchronous response handler
+     */
+    public <T> void invokeAPI(String path, String method, List<Pair> queryParams, Object body, MultiMap headerParams,
+                              Map<String, Object> formParams, String[] accepts, String[] contentTypes, String[] authNames,
+                              TypeReference<T> returnType, Handler<AsyncResult<T>> resultHandler) {
+
+        updateParamsForAuth(authNames, queryParams, headerParams);
+
+        if (accepts != null) {
+            headerParams.add(HttpHeaders.ACCEPT, selectHeaderAccept(accepts));
+        }
+
+        if (contentTypes != null) {
+            headerParams.add(HttpHeaders.CONTENT_TYPE, selectHeaderContentType(contentTypes));
+        }
+
+        HttpMethod httpMethod = HttpMethod.valueOf(method);
+        HttpRequest<Buffer> request = webClient.requestAbs(httpMethod, basePath + path);
+
+        if (httpMethod == HttpMethod.PATCH) {
+            request.putHeader("X-HTTP-Method-Override", "PATCH");
+        }
+
+        queryParams.forEach(entry -> {
+            if (entry.getValue() != null) {
+                request.addQueryParam(entry.getName(), entry.getValue());
+            }
+        });
+
+        headerParams.forEach(entry -> {
+            if (entry.getValue() != null) {
+                request.putHeader(entry.getKey(), entry.getValue());
+            }
+        });
+
+        defaultHeaders.forEach(entry -> {
+            if (entry.getValue() != null) {
+                request.putHeader(entry.getKey(), entry.getValue());
+            }
+        });
+
+        Handler<AsyncResult<HttpResponse<Buffer>>> responseHandler = buildResponseHandler(returnType, resultHandler);
+        if (body != null) {
+            sendBody(request, responseHandler, body);
+        } else if (formParams != null && !formParams.isEmpty()) {
+            Map<String, String> formMap = formParams.entrySet().stream().collect(toMap(Map.Entry::getKey, entry -> parameterToString(entry.getValue())));
+            MultiMap form = MultiMap.caseInsensitiveMultiMap().addAll(formMap);
+            request.sendForm(form, responseHandler);
+        } else {
+            request.send(responseHandler);
+        }
+    }
+
+    /**
+     * Sanitize filename by removing path.
+     * e.g. ../../sun.gif becomes sun.gif
+     *
+     * @param filename The filename to be sanitized
+     * @return The sanitized filename
+     */
+    protected String sanitizeFilename(String filename) {
+        return filename.replaceAll(".*[/\\\\]", "");
+    }
+
+    /**
+     * Create a filename from the given headers.
+     * When the headers have no "Content-Disposition" information, a random UUID name is generated.
+     *
+     * @param headers The HTTP response headers
+     * @return The filename
+     */
+    protected String generateFilename(MultiMap headers) {
+        String filename = UUID.randomUUID().toString();
+        String contentDisposition = headers.get("Content-Disposition");
+        if (contentDisposition != null && !contentDisposition.isEmpty()) {
+            Matcher matcher = CONTENT_DISPOSITION_PATTERN.matcher(contentDisposition);
+            if (matcher.find()) {
+                filename = sanitizeFilename(matcher.group(1));
+            }
+        }
+        return filename;
+    }
+
+    /**
+     * File Download handling.
+     *
+     * @param response The HTTP response
+     * @param handler The response handler
+     */
+    protected <T> void handleFileDownload(HttpResponse<Buffer> response, Handler<AsyncResult<T>> handler) {
+        FileSystem fs = getVertx().fileSystem();
+
+        String filename = generateFilename(response.headers());
+        Consumer<String> fileHandler = directory -> {
+            fs.open(directory + filename, FILE_DOWNLOAD_OPTIONS, asyncFileResult -> {
+                if (asyncFileResult.succeeded()) {
+                    AsyncFile asyncFile = asyncFileResult.result();
+                    asyncFile.write(response.bodyAsBuffer());
+                    //noinspection unchecked
+                    handler.handle(Future.succeededFuture((T) asyncFile));
+                } else {
+                    handler.handle(ApiException.fail(asyncFileResult.cause()));
+                }
+            });
+        };
+
+        String dir = getDownloadsDir();
+        if (dir != null && !dir.isEmpty()) {
+            fs.mkdirs(dir, mkdirResult -> {
+                String sanitizedFolder = dir.endsWith("/") ? dir : dir + "/";
+                fileHandler.accept(sanitizedFolder);
+            });
+        } else {
+            fileHandler.accept("");
+        }
+    }
+
+    /**
+     * Build a response handler for the HttpResponse.
+     *
+     * @param returnType The return type
+     * @param handler The response handler
+     * @return The HTTP response handler
+     */
+    protected <T> Handler<AsyncResult<HttpResponse<Buffer>>> buildResponseHandler(TypeReference<T> returnType,
+                                                                                  Handler<AsyncResult<T>> handler) {
+        return response -> {
+            AsyncResult<T> result;
+            if (response.succeeded()) {
+                HttpResponse<Buffer> httpResponse = response.result();
+                if (httpResponse.statusCode() / 100 == 2) {
+                    if (httpResponse.statusCode() == 204 || returnType == null) {
+                        result = Future.succeededFuture(null);
+                    } else {
+                        T resultContent;
+                        if ("byte[]".equals(returnType.getType().toString())) {
+                            resultContent = (T) httpResponse.body().getBytes();
+                        } else if (AsyncFile.class.equals(returnType.getType())) {
+                            handleFileDownload(httpResponse, handler);
+                            return;
+                        } else {
+                            resultContent = Json.decodeValue(httpResponse.body(), returnType);
+                        }
+                        result = Future.succeededFuture(resultContent);
+                    }
+                } else {
+                    result = ApiException.fail(httpResponse.statusMessage(), httpResponse.statusCode(), httpResponse.headers(), httpResponse.bodyAsString());
+                }
+            } else if (response.cause() instanceof ApiException) {
+                result = Future.failedFuture(response.cause());
+            } else {
+                result = ApiException.fail(500, response.cause() != null ? response.cause().getMessage() : null);
+            }
+            handler.handle(result);
+        };
+    }
+
+    /**
+     * Build the WebClient used to make HTTP requests.
+     *
+     * @param vertx Vertx
+     * @return WebClient
+     */
+    protected WebClient buildWebClient(Vertx vertx, JsonObject config) {
+
+        if (!config.containsKey("userAgent")) {
+            config.put("userAgent", "Swagger-Codegen/1.0.0/java");
+        }
+
+        return WebClient.create(vertx, new WebClientOptions(config));
+    }
+
+
+    /**
+     * Update query and header parameters based on authentication settings.
+     *
+     * @param authNames The authentications to apply
+     */
+    protected void updateParamsForAuth(String[] authNames, List<Pair> queryParams, MultiMap headerParams) {
+        for (String authName : authNames) {
+            Authentication auth = authentications.get(authName);
+            if (auth == null) throw new RuntimeException("Authentication undefined: " + authName);
+            auth.applyToParams(queryParams, headerParams);
+        }
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/ApiException.java

@@ -0,0 +1,121 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+package io.swagger.client;
+
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Future;
+import io.vertx.core.MultiMap;
+
+
+public class ApiException extends Exception {
+    private int code = 0;
+    private MultiMap responseHeaders = null;
+    private String responseBody = null;
+
+
+    public static <T> AsyncResult<T> fail(int failureCode, String message) {
+        return Future.failedFuture(new ApiException(failureCode, message));
+    }
+
+    public static <T> AsyncResult<T> fail(Throwable throwable) {
+        return Future.failedFuture(new ApiException(throwable));
+    }
+
+    public static <T> AsyncResult<T> fail(String message) {
+        return Future.failedFuture(new ApiException(message));
+    }
+
+    public static <T> AsyncResult<T> fail(String message, Throwable throwable, int code, MultiMap responseHeaders) {
+        return Future.failedFuture(new ApiException(message, throwable, code, responseHeaders, null));
+    }
+
+    public static <T> AsyncResult<T> fail(String message, Throwable throwable, int code, MultiMap responseHeaders, String responseBody) {
+        return Future.failedFuture(new ApiException(message, throwable, code, responseHeaders, responseBody));
+    }
+
+    public static <T> AsyncResult<T> fail(String message, int code, MultiMap responseHeaders, String responseBody) {
+        return Future.failedFuture(new ApiException(message, (Throwable) null, code, responseHeaders, responseBody));
+    }
+
+    public static <T> AsyncResult<T> fail(int code, MultiMap responseHeaders, String responseBody) {
+        return Future.failedFuture(new ApiException((String) null, (Throwable) null, code, responseHeaders, responseBody));
+    }
+
+    public ApiException() {}
+
+    public ApiException(Throwable throwable) {
+        super(throwable);
+    }
+
+    public ApiException(String message) {
+        super(message);
+    }
+
+    public ApiException(String message, Throwable throwable, int code, MultiMap responseHeaders, String responseBody) {
+        super(message, throwable);
+        this.code = code;
+        this.responseHeaders = responseHeaders;
+        this.responseBody = responseBody;
+    }
+
+    public ApiException(String message, int code, MultiMap responseHeaders, String responseBody) {
+        this(message, (Throwable) null, code, responseHeaders, responseBody);
+    }
+
+    public ApiException(String message, Throwable throwable, int code, MultiMap responseHeaders) {
+        this(message, throwable, code, responseHeaders, null);
+    }
+
+    public ApiException(int code, MultiMap responseHeaders, String responseBody) {
+        this((String) null, (Throwable) null, code, responseHeaders, responseBody);
+    }
+
+    public ApiException(int code, String message) {
+        super(message);
+        this.code = code;
+    }
+
+    public ApiException(int code, String message, MultiMap responseHeaders, String responseBody) {
+        this(code, message);
+        this.responseHeaders = responseHeaders;
+        this.responseBody = responseBody;
+    }
+
+    /**
+     * Get the HTTP status code.
+     *
+     * @return HTTP status code
+     */
+    public int getCode() {
+        return code;
+    }
+
+    /**
+     * Get the HTTP response headers.
+     *
+     * @return A map of list of string
+     */
+    public MultiMap getResponseHeaders() {
+        return responseHeaders;
+    }
+
+    /**
+     * Get the HTTP response body.
+     *
+     * @return Response body in the form of string
+     */
+    public String getResponseBody() {
+        return responseBody;
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/Configuration.java

@@ -0,0 +1,42 @@
+package io.swagger.client;
+
+import io.vertx.core.Vertx;
+import io.vertx.core.json.JsonObject;
+
+import java.util.Objects;
+
+public class Configuration {
+
+    private static ApiClient defaultApiClient = null;
+
+    /**
+     * Setup the default API client.
+     * Will be used by API instances when a client is not provided.
+     *
+     * @return Default API client
+     */
+    public synchronized static ApiClient setupDefaultApiClient(Vertx vertx, JsonObject config) {
+        defaultApiClient = new ApiClient(vertx, config);
+        return defaultApiClient;
+    }
+
+    /**
+     * Get the default API client, which would be used when creating API
+     * instances without providing an API client.
+     *
+     * @return Default API client
+     */
+    public synchronized static ApiClient getDefaultApiClient() {
+        return defaultApiClient;
+    }
+
+    /**
+     * Set the default API client, which would be used when creating API
+     * instances without providing an API client.
+     *
+     * @param apiClient API client
+     */
+    public synchronized static void setDefaultApiClient(ApiClient apiClient) {
+        defaultApiClient = apiClient;
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/CustomInstantDeserializer.java

@@ -0,0 +1,232 @@
+package io.swagger.client;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonTokenId;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.datatype.threetenbp.DateTimeUtils;
+import com.fasterxml.jackson.datatype.threetenbp.DecimalUtils;
+import com.fasterxml.jackson.datatype.threetenbp.deser.ThreeTenDateTimeDeserializerBase;
+import com.fasterxml.jackson.datatype.threetenbp.function.BiFunction;
+import com.fasterxml.jackson.datatype.threetenbp.function.Function;
+import org.threeten.bp.DateTimeException;
+import org.threeten.bp.Instant;
+import org.threeten.bp.OffsetDateTime;
+import org.threeten.bp.ZoneId;
+import org.threeten.bp.ZonedDateTime;
+import org.threeten.bp.format.DateTimeFormatter;
+import org.threeten.bp.temporal.Temporal;
+import org.threeten.bp.temporal.TemporalAccessor;
+
+import java.io.IOException;
+import java.math.BigDecimal;
+
+/**
+ * Deserializer for ThreeTen temporal {@link Instant}s, {@link OffsetDateTime}, and {@link ZonedDateTime}s.
+ * Adapted from the jackson threetenbp InstantDeserializer to add support for deserializing rfc822 format.
+ *
+ * @author Nick Williams
+ */
+public class CustomInstantDeserializer<T extends Temporal>
+    extends ThreeTenDateTimeDeserializerBase<T> {
+  private static final long serialVersionUID = 1L;
+
+  public static final CustomInstantDeserializer<Instant> INSTANT = new CustomInstantDeserializer<Instant>(
+      Instant.class, DateTimeFormatter.ISO_INSTANT,
+      new Function<TemporalAccessor, Instant>() {
+        @Override
+        public Instant apply(TemporalAccessor temporalAccessor) {
+          return Instant.from(temporalAccessor);
+        }
+      },
+      new Function<FromIntegerArguments, Instant>() {
+        @Override
+        public Instant apply(FromIntegerArguments a) {
+          return Instant.ofEpochMilli(a.value);
+        }
+      },
+      new Function<FromDecimalArguments, Instant>() {
+        @Override
+        public Instant apply(FromDecimalArguments a) {
+          return Instant.ofEpochSecond(a.integer, a.fraction);
+        }
+      },
+      null
+  );
+
+  public static final CustomInstantDeserializer<OffsetDateTime> OFFSET_DATE_TIME = new CustomInstantDeserializer<OffsetDateTime>(
+      OffsetDateTime.class, DateTimeFormatter.ISO_OFFSET_DATE_TIME,
+      new Function<TemporalAccessor, OffsetDateTime>() {
+        @Override
+        public OffsetDateTime apply(TemporalAccessor temporalAccessor) {
+          return OffsetDateTime.from(temporalAccessor);
+        }
+      },
+      new Function<FromIntegerArguments, OffsetDateTime>() {
+        @Override
+        public OffsetDateTime apply(FromIntegerArguments a) {
+          return OffsetDateTime.ofInstant(Instant.ofEpochMilli(a.value), a.zoneId);
+        }
+      },
+      new Function<FromDecimalArguments, OffsetDateTime>() {
+        @Override
+        public OffsetDateTime apply(FromDecimalArguments a) {
+          return OffsetDateTime.ofInstant(Instant.ofEpochSecond(a.integer, a.fraction), a.zoneId);
+        }
+      },
+      new BiFunction<OffsetDateTime, ZoneId, OffsetDateTime>() {
+        @Override
+        public OffsetDateTime apply(OffsetDateTime d, ZoneId z) {
+          return d.withOffsetSameInstant(z.getRules().getOffset(d.toLocalDateTime()));
+        }
+      }
+  );
+
+  public static final CustomInstantDeserializer<ZonedDateTime> ZONED_DATE_TIME = new CustomInstantDeserializer<ZonedDateTime>(
+      ZonedDateTime.class, DateTimeFormatter.ISO_ZONED_DATE_TIME,
+      new Function<TemporalAccessor, ZonedDateTime>() {
+        @Override
+        public ZonedDateTime apply(TemporalAccessor temporalAccessor) {
+          return ZonedDateTime.from(temporalAccessor);
+        }
+      },
+      new Function<FromIntegerArguments, ZonedDateTime>() {
+        @Override
+        public ZonedDateTime apply(FromIntegerArguments a) {
+          return ZonedDateTime.ofInstant(Instant.ofEpochMilli(a.value), a.zoneId);
+        }
+      },
+      new Function<FromDecimalArguments, ZonedDateTime>() {
+        @Override
+        public ZonedDateTime apply(FromDecimalArguments a) {
+          return ZonedDateTime.ofInstant(Instant.ofEpochSecond(a.integer, a.fraction), a.zoneId);
+        }
+      },
+      new BiFunction<ZonedDateTime, ZoneId, ZonedDateTime>() {
+        @Override
+        public ZonedDateTime apply(ZonedDateTime zonedDateTime, ZoneId zoneId) {
+          return zonedDateTime.withZoneSameInstant(zoneId);
+        }
+      }
+  );
+
+  protected final Function<FromIntegerArguments, T> fromMilliseconds;
+
+  protected final Function<FromDecimalArguments, T> fromNanoseconds;
+
+  protected final Function<TemporalAccessor, T> parsedToValue;
+
+  protected final BiFunction<T, ZoneId, T> adjust;
+
+  protected CustomInstantDeserializer(Class<T> supportedType,
+                    DateTimeFormatter parser,
+                    Function<TemporalAccessor, T> parsedToValue,
+                    Function<FromIntegerArguments, T> fromMilliseconds,
+                    Function<FromDecimalArguments, T> fromNanoseconds,
+                    BiFunction<T, ZoneId, T> adjust) {
+    super(supportedType, parser);
+    this.parsedToValue = parsedToValue;
+    this.fromMilliseconds = fromMilliseconds;
+    this.fromNanoseconds = fromNanoseconds;
+    this.adjust = adjust == null ? new BiFunction<T, ZoneId, T>() {
+      @Override
+      public T apply(T t, ZoneId zoneId) {
+        return t;
+      }
+    } : adjust;
+  }
+
+  @SuppressWarnings("unchecked")
+  protected CustomInstantDeserializer(CustomInstantDeserializer<T> base, DateTimeFormatter f) {
+    super((Class<T>) base.handledType(), f);
+    parsedToValue = base.parsedToValue;
+    fromMilliseconds = base.fromMilliseconds;
+    fromNanoseconds = base.fromNanoseconds;
+    adjust = base.adjust;
+  }
+
+  @Override
+  protected JsonDeserializer<T> withDateFormat(DateTimeFormatter dtf) {
+    if (dtf == _formatter) {
+      return this;
+    }
+    return new CustomInstantDeserializer<T>(this, dtf);
+  }
+
+  @Override
+  public T deserialize(JsonParser parser, DeserializationContext context) throws IOException {
+    //NOTE: Timestamps contain no timezone info, and are always in configured TZ. Only
+    //string values have to be adjusted to the configured TZ.
+    switch (parser.getCurrentTokenId()) {
+      case JsonTokenId.ID_NUMBER_FLOAT: {
+        BigDecimal value = parser.getDecimalValue();
+        long seconds = value.longValue();
+        int nanoseconds = DecimalUtils.extractNanosecondDecimal(value, seconds);
+        return fromNanoseconds.apply(new FromDecimalArguments(
+            seconds, nanoseconds, getZone(context)));
+      }
+
+      case JsonTokenId.ID_NUMBER_INT: {
+        long timestamp = parser.getLongValue();
+        if (context.isEnabled(DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS)) {
+          return this.fromNanoseconds.apply(new FromDecimalArguments(
+              timestamp, 0, this.getZone(context)
+          ));
+        }
+        return this.fromMilliseconds.apply(new FromIntegerArguments(
+            timestamp, this.getZone(context)
+        ));
+      }
+
+      case JsonTokenId.ID_STRING: {
+        String string = parser.getText().trim();
+        if (string.length() == 0) {
+          return null;
+        }
+        if (string.endsWith("+0000")) {
+          string = string.substring(0, string.length() - 5) + "Z";
+        }
+        T value;
+        try {
+          TemporalAccessor acc = _formatter.parse(string);
+          value = parsedToValue.apply(acc);
+          if (context.isEnabled(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE)) {
+            return adjust.apply(value, this.getZone(context));
+          }
+        } catch (DateTimeException e) {
+          throw _peelDTE(e);
+        }
+        return value;
+      }
+    }
+    throw context.mappingException("Expected type float, integer, or string.");
+  }
+
+  private ZoneId getZone(DeserializationContext context) {
+    // Instants are always in UTC, so don't waste compute cycles
+    return (_valueClass == Instant.class) ? null : DateTimeUtils.timeZoneToZoneId(context.getTimeZone());
+  }
+
+  private static class FromIntegerArguments {
+    public final long value;
+    public final ZoneId zoneId;
+
+    private FromIntegerArguments(long value, ZoneId zoneId) {
+      this.value = value;
+      this.zoneId = zoneId;
+    }
+  }
+
+  private static class FromDecimalArguments {
+    public final long integer;
+    public final int fraction;
+    public final ZoneId zoneId;
+
+    private FromDecimalArguments(long integer, int fraction, ZoneId zoneId) {
+      this.integer = integer;
+      this.fraction = fraction;
+      this.zoneId = zoneId;
+    }
+  }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/Pair.java

@@ -0,0 +1,52 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+package io.swagger.client;
+
+
+public class Pair {
+    private String name = "";
+    private String value = "";
+
+    public Pair (String name, String value) {
+        setName(name);
+        setValue(value);
+    }
+
+    private void setName(String name) {
+        if (!isValidString(name)) return;
+
+        this.name = name;
+    }
+
+    private void setValue(String value) {
+        if (!isValidString(value)) return;
+
+        this.value = value;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public String getValue() {
+        return this.value;
+    }
+
+    private boolean isValidString(String arg) {
+        if (arg == null) return false;
+        if (arg.trim().isEmpty()) return false;
+
+        return true;
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/RFC3339DateFormat.java

@@ -0,0 +1,32 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+package io.swagger.client;
+
+import com.fasterxml.jackson.databind.util.ISO8601DateFormat;
+import com.fasterxml.jackson.databind.util.ISO8601Utils;
+
+import java.text.FieldPosition;
+import java.util.Date;
+
+
+public class RFC3339DateFormat extends ISO8601DateFormat {
+
+  // Same as ISO8601DateFormat but serializing milliseconds.
+  @Override
+  public StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition fieldPosition) {
+    String value = ISO8601Utils.format(date, true);
+    toAppendTo.append(value);
+    return toAppendTo;
+  }
+
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/StringUtil.java

@@ -0,0 +1,55 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+package io.swagger.client;
+
+
+public class StringUtil {
+  /**
+   * Check if the given array contains the given value (with case-insensitive comparison).
+   *
+   * @param array The array
+   * @param value The value to search
+   * @return true if the array contains the value
+   */
+  public static boolean containsIgnoreCase(String[] array, String value) {
+    for (String str : array) {
+      if (value == null && str == null) return true;
+      if (value != null && value.equalsIgnoreCase(str)) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Join an array of strings with the given separator.
+   * <p>
+   * Note: This might be replaced by utility method from commons-lang or guava someday
+   * if one of those libraries is added as dependency.
+   * </p>
+   *
+   * @param array     The array of strings
+   * @param separator The separator
+   * @return the resulting string
+   */
+  public static String join(String[] array, String separator) {
+    int len = array.length;
+    if (len == 0) return "";
+
+    StringBuilder out = new StringBuilder();
+    out.append(array[0]);
+    for (int i = 1; i < len; i++) {
+      out.append(separator).append(array[i]);
+    }
+    return out.toString();
+  }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/FakeApi.java

@@ -0,0 +1,32 @@
+package io.swagger.client.api;
+
+import java.math.BigDecimal;
+import io.swagger.client.model.Client;
+import org.threeten.bp.LocalDate;
+import org.threeten.bp.OffsetDateTime;
+import io.swagger.client.model.OuterComposite;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.json.JsonObject;
+
+import java.util.*;
+
+public interface FakeApi {
+
+    void fakeOuterBooleanSerialize(Boolean body, Handler<AsyncResult<Boolean>> handler);
+
+    void fakeOuterCompositeSerialize(OuterComposite body, Handler<AsyncResult<OuterComposite>> handler);
+
+    void fakeOuterNumberSerialize(BigDecimal body, Handler<AsyncResult<BigDecimal>> handler);
+
+    void fakeOuterStringSerialize(String body, Handler<AsyncResult<String>> handler);
+
+    void testClientModel(Client body, Handler<AsyncResult<Client>> handler);
+
+    void testEndpointParameters(BigDecimal number, Double _double, String patternWithoutDelimiter, byte[] _byte, Integer integer, Integer int32, Long int64, Float _float, String string, byte[] binary, LocalDate date, OffsetDateTime dateTime, String password, String paramCallback, Handler<AsyncResult<Void>> handler);
+
+    void testEnumParameters(List<String> enumFormStringArray, String enumFormString, List<String> enumHeaderStringArray, String enumHeaderString, List<String> enumQueryStringArray, String enumQueryString, Integer enumQueryInteger, Double enumQueryDouble, Handler<AsyncResult<Void>> handler);
+
+    void testJsonFormData(String param, String param2, Handler<AsyncResult<Void>> handler);
+
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/FakeApiImpl.java

@@ -0,0 +1,357 @@
+package io.swagger.client.api;
+
+import java.math.BigDecimal;
+import io.swagger.client.model.Client;
+import org.threeten.bp.LocalDate;
+import org.threeten.bp.OffsetDateTime;
+import io.swagger.client.model.OuterComposite;
+
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.json.JsonObject;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+
+import java.util.*;
+
+import io.swagger.client.ApiClient;
+import io.swagger.client.ApiException;
+import io.swagger.client.Configuration;
+import io.swagger.client.Pair;
+
+
+public class FakeApiImpl implements FakeApi {
+
+    private ApiClient apiClient;
+
+    public FakeApiImpl() {
+        this(null);
+    }
+
+    public FakeApiImpl(ApiClient apiClient) {
+        this.apiClient = apiClient != null ? apiClient : Configuration.getDefaultApiClient();
+    }
+
+    public ApiClient getApiClient() {
+        return apiClient;
+    }
+
+    public void setApiClient(ApiClient apiClient) {
+        this.apiClient = apiClient;
+    }
+
+    /**
+     * 
+     * Test serialization of outer boolean types
+     * @param body Input boolean as post body (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void fakeOuterBooleanSerialize(Boolean body, Handler<AsyncResult<Boolean>> resultHandler) {
+        Object localVarBody = body;
+        
+        // create path and map variables
+        String localVarPath = "/fake/outer/boolean";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = {  };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+        TypeReference<Boolean> localVarReturnType = new TypeReference<Boolean>() {};
+        apiClient.invokeAPI(localVarPath, "POST", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+    /**
+     * 
+     * Test serialization of object with outer number type
+     * @param body Input composite as post body (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void fakeOuterCompositeSerialize(OuterComposite body, Handler<AsyncResult<OuterComposite>> resultHandler) {
+        Object localVarBody = body;
+        
+        // create path and map variables
+        String localVarPath = "/fake/outer/composite";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = {  };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+        TypeReference<OuterComposite> localVarReturnType = new TypeReference<OuterComposite>() {};
+        apiClient.invokeAPI(localVarPath, "POST", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+    /**
+     * 
+     * Test serialization of outer number types
+     * @param body Input number as post body (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void fakeOuterNumberSerialize(BigDecimal body, Handler<AsyncResult<BigDecimal>> resultHandler) {
+        Object localVarBody = body;
+        
+        // create path and map variables
+        String localVarPath = "/fake/outer/number";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = {  };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+        TypeReference<BigDecimal> localVarReturnType = new TypeReference<BigDecimal>() {};
+        apiClient.invokeAPI(localVarPath, "POST", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+    /**
+     * 
+     * Test serialization of outer string types
+     * @param body Input string as post body (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void fakeOuterStringSerialize(String body, Handler<AsyncResult<String>> resultHandler) {
+        Object localVarBody = body;
+        
+        // create path and map variables
+        String localVarPath = "/fake/outer/string";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = {  };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+        TypeReference<String> localVarReturnType = new TypeReference<String>() {};
+        apiClient.invokeAPI(localVarPath, "POST", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+    /**
+     * To test \&quot;client\&quot; model
+     * To test \&quot;client\&quot; model
+     * @param body client model (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void testClientModel(Client body, Handler<AsyncResult<Client>> resultHandler) {
+        Object localVarBody = body;
+        
+        // verify the required parameter 'body' is set
+        if (body == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'body' when calling testClientModel"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/fake";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/json" };
+        String[] localVarContentTypes = { "application/json" };
+        String[] localVarAuthNames = new String[] {  };
+        TypeReference<Client> localVarReturnType = new TypeReference<Client>() {};
+        apiClient.invokeAPI(localVarPath, "PATCH", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+    /**
+     * Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+     * Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+     * @param number None (required)
+     * @param _double None (required)
+     * @param patternWithoutDelimiter None (required)
+     * @param _byte None (required)
+     * @param integer None (optional)
+     * @param int32 None (optional)
+     * @param int64 None (optional)
+     * @param _float None (optional)
+     * @param string None (optional)
+     * @param binary None (optional)
+     * @param date None (optional)
+     * @param dateTime None (optional)
+     * @param password None (optional)
+     * @param paramCallback None (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void testEndpointParameters(BigDecimal number, Double _double, String patternWithoutDelimiter, byte[] _byte, Integer integer, Integer int32, Long int64, Float _float, String string, byte[] binary, LocalDate date, OffsetDateTime dateTime, String password, String paramCallback, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'number' is set
+        if (number == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'number' when calling testEndpointParameters"));
+            return;
+        }
+        
+        // verify the required parameter '_double' is set
+        if (_double == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter '_double' when calling testEndpointParameters"));
+            return;
+        }
+        
+        // verify the required parameter 'patternWithoutDelimiter' is set
+        if (patternWithoutDelimiter == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'patternWithoutDelimiter' when calling testEndpointParameters"));
+            return;
+        }
+        
+        // verify the required parameter '_byte' is set
+        if (_byte == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter '_byte' when calling testEndpointParameters"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/fake";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        if (integer != null) localVarFormParams.put("integer", integer);
+if (int32 != null) localVarFormParams.put("int32", int32);
+if (int64 != null) localVarFormParams.put("int64", int64);
+if (number != null) localVarFormParams.put("number", number);
+if (_float != null) localVarFormParams.put("float", _float);
+if (_double != null) localVarFormParams.put("double", _double);
+if (string != null) localVarFormParams.put("string", string);
+if (patternWithoutDelimiter != null) localVarFormParams.put("pattern_without_delimiter", patternWithoutDelimiter);
+if (_byte != null) localVarFormParams.put("byte", _byte);
+if (binary != null) localVarFormParams.put("binary", binary);
+if (date != null) localVarFormParams.put("date", date);
+if (dateTime != null) localVarFormParams.put("dateTime", dateTime);
+if (password != null) localVarFormParams.put("password", password);
+if (paramCallback != null) localVarFormParams.put("callback", paramCallback);
+
+        String[] localVarAccepts = { "application/xml; charset=utf-8", "application/json; charset=utf-8" };
+        String[] localVarContentTypes = { "application/xml; charset=utf-8", "application/json; charset=utf-8" };
+        String[] localVarAuthNames = new String[] { "http_basic_test" };
+
+        apiClient.invokeAPI(localVarPath, "POST", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+    /**
+     * To test enum parameters
+     * To test enum parameters
+     * @param enumFormStringArray Form parameter enum test (string array) (optional)
+     * @param enumFormString Form parameter enum test (string) (optional, default to -efg)
+     * @param enumHeaderStringArray Header parameter enum test (string array) (optional)
+     * @param enumHeaderString Header parameter enum test (string) (optional, default to -efg)
+     * @param enumQueryStringArray Query parameter enum test (string array) (optional)
+     * @param enumQueryString Query parameter enum test (string) (optional, default to -efg)
+     * @param enumQueryInteger Query parameter enum test (double) (optional)
+     * @param enumQueryDouble Query parameter enum test (double) (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void testEnumParameters(List<String> enumFormStringArray, String enumFormString, List<String> enumHeaderStringArray, String enumHeaderString, List<String> enumQueryStringArray, String enumQueryString, Integer enumQueryInteger, Double enumQueryDouble, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = null;
+        
+        // create path and map variables
+        String localVarPath = "/fake";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+        localVarQueryParams.addAll(apiClient.parameterToPairs("csv", "enum_query_string_array", enumQueryStringArray));
+        localVarQueryParams.addAll(apiClient.parameterToPairs("", "enum_query_string", enumQueryString));
+        localVarQueryParams.addAll(apiClient.parameterToPairs("", "enum_query_integer", enumQueryInteger));
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        if (enumHeaderStringArray != null)
+        localVarHeaderParams.add("enum_header_string_array", apiClient.parameterToString(enumHeaderStringArray));
+if (enumHeaderString != null)
+        localVarHeaderParams.add("enum_header_string", apiClient.parameterToString(enumHeaderString));
+
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        if (enumFormStringArray != null) localVarFormParams.put("enum_form_string_array", enumFormStringArray);
+if (enumFormString != null) localVarFormParams.put("enum_form_string", enumFormString);
+if (enumQueryDouble != null) localVarFormParams.put("enum_query_double", enumQueryDouble);
+
+        String[] localVarAccepts = { "*/*" };
+        String[] localVarContentTypes = { "*/*" };
+        String[] localVarAuthNames = new String[] {  };
+
+        apiClient.invokeAPI(localVarPath, "GET", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+    /**
+     * test json serialization of form data
+     * 
+     * @param param field1 (required)
+     * @param param2 field2 (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void testJsonFormData(String param, String param2, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'param' is set
+        if (param == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'param' when calling testJsonFormData"));
+            return;
+        }
+        
+        // verify the required parameter 'param2' is set
+        if (param2 == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'param2' when calling testJsonFormData"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/fake/jsonFormData";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        if (param != null) localVarFormParams.put("param", param);
+if (param2 != null) localVarFormParams.put("param2", param2);
+
+        String[] localVarAccepts = {  };
+        String[] localVarContentTypes = { "application/json" };
+        String[] localVarAuthNames = new String[] {  };
+
+        apiClient.invokeAPI(localVarPath, "GET", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/FakeClassnameTags123Api.java

@@ -0,0 +1,14 @@
+package io.swagger.client.api;
+
+import io.swagger.client.model.Client;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.json.JsonObject;
+
+import java.util.*;
+
+public interface FakeClassnameTags123Api {
+
+    void testClassname(Client body, Handler<AsyncResult<Client>> handler);
+
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/FakeClassnameTags123ApiImpl.java

@@ -0,0 +1,74 @@
+package io.swagger.client.api;
+
+import io.swagger.client.model.Client;
+
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.json.JsonObject;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+
+import java.util.*;
+
+import io.swagger.client.ApiClient;
+import io.swagger.client.ApiException;
+import io.swagger.client.Configuration;
+import io.swagger.client.Pair;
+
+
+public class FakeClassnameTags123ApiImpl implements FakeClassnameTags123Api {
+
+    private ApiClient apiClient;
+
+    public FakeClassnameTags123ApiImpl() {
+        this(null);
+    }
+
+    public FakeClassnameTags123ApiImpl(ApiClient apiClient) {
+        this.apiClient = apiClient != null ? apiClient : Configuration.getDefaultApiClient();
+    }
+
+    public ApiClient getApiClient() {
+        return apiClient;
+    }
+
+    public void setApiClient(ApiClient apiClient) {
+        this.apiClient = apiClient;
+    }
+
+    /**
+     * To test class name in snake case
+     * 
+     * @param body client model (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void testClassname(Client body, Handler<AsyncResult<Client>> resultHandler) {
+        Object localVarBody = body;
+        
+        // verify the required parameter 'body' is set
+        if (body == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'body' when calling testClassname"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/fake_classname_test";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/json" };
+        String[] localVarContentTypes = { "application/json" };
+        String[] localVarAuthNames = new String[] { "api_key_query" };
+        TypeReference<Client> localVarReturnType = new TypeReference<Client>() {};
+        apiClient.invokeAPI(localVarPath, "PATCH", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/PetApi.java

@@ -0,0 +1,30 @@
+package io.swagger.client.api;
+
+import io.vertx.core.file.AsyncFile;
+import io.swagger.client.model.ModelApiResponse;
+import io.swagger.client.model.Pet;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.json.JsonObject;
+
+import java.util.*;
+
+public interface PetApi {
+
+    void addPet(Pet body, Handler<AsyncResult<Void>> handler);
+
+    void deletePet(Long petId, String apiKey, Handler<AsyncResult<Void>> handler);
+
+    void findPetsByStatus(List<String> status, Handler<AsyncResult<List<Pet>>> handler);
+
+    void findPetsByTags(List<String> tags, Handler<AsyncResult<List<Pet>>> handler);
+
+    void getPetById(Long petId, Handler<AsyncResult<Pet>> handler);
+
+    void updatePet(Pet body, Handler<AsyncResult<Void>> handler);
+
+    void updatePetWithForm(Long petId, String name, String status, Handler<AsyncResult<Void>> handler);
+
+    void uploadFile(Long petId, String additionalMetadata, AsyncFile file, Handler<AsyncResult<ModelApiResponse>> handler);
+
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/PetApiImpl.java

@@ -0,0 +1,327 @@
+package io.swagger.client.api;
+
+import io.vertx.core.file.AsyncFile;
+import io.swagger.client.model.ModelApiResponse;
+import io.swagger.client.model.Pet;
+
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.json.JsonObject;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+
+import java.util.*;
+
+import io.swagger.client.ApiClient;
+import io.swagger.client.ApiException;
+import io.swagger.client.Configuration;
+import io.swagger.client.Pair;
+
+
+public class PetApiImpl implements PetApi {
+
+    private ApiClient apiClient;
+
+    public PetApiImpl() {
+        this(null);
+    }
+
+    public PetApiImpl(ApiClient apiClient) {
+        this.apiClient = apiClient != null ? apiClient : Configuration.getDefaultApiClient();
+    }
+
+    public ApiClient getApiClient() {
+        return apiClient;
+    }
+
+    public void setApiClient(ApiClient apiClient) {
+        this.apiClient = apiClient;
+    }
+
+    /**
+     * Add a new pet to the store
+     * 
+     * @param body Pet object that needs to be added to the store (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void addPet(Pet body, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = body;
+        
+        // verify the required parameter 'body' is set
+        if (body == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'body' when calling addPet"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/pet";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = { "application/json", "application/xml" };
+        String[] localVarAuthNames = new String[] { "petstore_auth" };
+
+        apiClient.invokeAPI(localVarPath, "POST", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+    /**
+     * Deletes a pet
+     * 
+     * @param petId Pet id to delete (required)
+     * @param apiKey  (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void deletePet(Long petId, String apiKey, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'petId' is set
+        if (petId == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'petId' when calling deletePet"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/pet/{petId}".replaceAll("\\{" + "petId" + "\\}", petId.toString());
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        if (apiKey != null)
+        localVarHeaderParams.add("api_key", apiClient.parameterToString(apiKey));
+
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] { "petstore_auth" };
+
+        apiClient.invokeAPI(localVarPath, "DELETE", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+    /**
+     * Finds Pets by status
+     * Multiple status values can be provided with comma separated strings
+     * @param status Status values that need to be considered for filter (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void findPetsByStatus(List<String> status, Handler<AsyncResult<List<Pet>>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'status' is set
+        if (status == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'status' when calling findPetsByStatus"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/pet/findByStatus";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+        localVarQueryParams.addAll(apiClient.parameterToPairs("csv", "status", status));
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] { "petstore_auth" };
+        TypeReference<List<Pet>> localVarReturnType = new TypeReference<List<Pet>>() {};
+        apiClient.invokeAPI(localVarPath, "GET", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+    /**
+     * Finds Pets by tags
+     * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+     * @param tags Tags to filter by (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void findPetsByTags(List<String> tags, Handler<AsyncResult<List<Pet>>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'tags' is set
+        if (tags == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'tags' when calling findPetsByTags"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/pet/findByTags";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+        localVarQueryParams.addAll(apiClient.parameterToPairs("csv", "tags", tags));
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] { "petstore_auth" };
+        TypeReference<List<Pet>> localVarReturnType = new TypeReference<List<Pet>>() {};
+        apiClient.invokeAPI(localVarPath, "GET", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+    /**
+     * Find pet by ID
+     * Returns a single pet
+     * @param petId ID of pet to return (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void getPetById(Long petId, Handler<AsyncResult<Pet>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'petId' is set
+        if (petId == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'petId' when calling getPetById"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/pet/{petId}".replaceAll("\\{" + "petId" + "\\}", petId.toString());
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] { "api_key" };
+        TypeReference<Pet> localVarReturnType = new TypeReference<Pet>() {};
+        apiClient.invokeAPI(localVarPath, "GET", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+    /**
+     * Update an existing pet
+     * 
+     * @param body Pet object that needs to be added to the store (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void updatePet(Pet body, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = body;
+        
+        // verify the required parameter 'body' is set
+        if (body == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'body' when calling updatePet"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/pet";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = { "application/json", "application/xml" };
+        String[] localVarAuthNames = new String[] { "petstore_auth" };
+
+        apiClient.invokeAPI(localVarPath, "PUT", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+    /**
+     * Updates a pet in the store with form data
+     * 
+     * @param petId ID of pet that needs to be updated (required)
+     * @param name Updated name of the pet (optional)
+     * @param status Updated status of the pet (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void updatePetWithForm(Long petId, String name, String status, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'petId' is set
+        if (petId == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'petId' when calling updatePetWithForm"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/pet/{petId}".replaceAll("\\{" + "petId" + "\\}", petId.toString());
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        if (name != null) localVarFormParams.put("name", name);
+if (status != null) localVarFormParams.put("status", status);
+
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = { "application/x-www-form-urlencoded" };
+        String[] localVarAuthNames = new String[] { "petstore_auth" };
+
+        apiClient.invokeAPI(localVarPath, "POST", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+    /**
+     * uploads an image
+     * 
+     * @param petId ID of pet to update (required)
+     * @param additionalMetadata Additional data to pass to server (optional)
+     * @param file file to upload (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void uploadFile(Long petId, String additionalMetadata, AsyncFile file, Handler<AsyncResult<ModelApiResponse>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'petId' is set
+        if (petId == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'petId' when calling uploadFile"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/pet/{petId}/uploadImage".replaceAll("\\{" + "petId" + "\\}", petId.toString());
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        if (additionalMetadata != null) localVarFormParams.put("additionalMetadata", additionalMetadata);
+if (file != null) localVarFormParams.put("file", file);
+
+        String[] localVarAccepts = { "application/json" };
+        String[] localVarContentTypes = { "multipart/form-data" };
+        String[] localVarAuthNames = new String[] { "petstore_auth" };
+        TypeReference<ModelApiResponse> localVarReturnType = new TypeReference<ModelApiResponse>() {};
+        apiClient.invokeAPI(localVarPath, "POST", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/StoreApi.java

@@ -0,0 +1,20 @@
+package io.swagger.client.api;
+
+import io.swagger.client.model.Order;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.json.JsonObject;
+
+import java.util.*;
+
+public interface StoreApi {
+
+    void deleteOrder(String orderId, Handler<AsyncResult<Void>> handler);
+
+    void getInventory(Handler<AsyncResult<Map<String, Integer>>> handler);
+
+    void getOrderById(Long orderId, Handler<AsyncResult<Order>> handler);
+
+    void placeOrder(Order body, Handler<AsyncResult<Order>> handler);
+
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/StoreApiImpl.java

@@ -0,0 +1,169 @@
+package io.swagger.client.api;
+
+import io.swagger.client.model.Order;
+
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.json.JsonObject;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+
+import java.util.*;
+
+import io.swagger.client.ApiClient;
+import io.swagger.client.ApiException;
+import io.swagger.client.Configuration;
+import io.swagger.client.Pair;
+
+
+public class StoreApiImpl implements StoreApi {
+
+    private ApiClient apiClient;
+
+    public StoreApiImpl() {
+        this(null);
+    }
+
+    public StoreApiImpl(ApiClient apiClient) {
+        this.apiClient = apiClient != null ? apiClient : Configuration.getDefaultApiClient();
+    }
+
+    public ApiClient getApiClient() {
+        return apiClient;
+    }
+
+    public void setApiClient(ApiClient apiClient) {
+        this.apiClient = apiClient;
+    }
+
+    /**
+     * Delete purchase order by ID
+     * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+     * @param orderId ID of the order that needs to be deleted (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void deleteOrder(String orderId, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'orderId' is set
+        if (orderId == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'orderId' when calling deleteOrder"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/store/order/{order_id}".replaceAll("\\{" + "order_id" + "\\}", orderId.toString());
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+
+        apiClient.invokeAPI(localVarPath, "DELETE", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+    /**
+     * Returns pet inventories by status
+     * Returns a map of status codes to quantities
+     * @param resultHandler Asynchronous result handler
+     */
+    public void getInventory(Handler<AsyncResult<Map<String, Integer>>> resultHandler) {
+        Object localVarBody = null;
+        
+        // create path and map variables
+        String localVarPath = "/store/inventory";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] { "api_key" };
+        TypeReference<Map<String, Integer>> localVarReturnType = new TypeReference<Map<String, Integer>>() {};
+        apiClient.invokeAPI(localVarPath, "GET", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+    /**
+     * Find purchase order by ID
+     * For valid response try integer IDs with value &lt;&#x3D; 5 or &gt; 10. Other values will generated exceptions
+     * @param orderId ID of pet that needs to be fetched (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void getOrderById(Long orderId, Handler<AsyncResult<Order>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'orderId' is set
+        if (orderId == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'orderId' when calling getOrderById"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/store/order/{order_id}".replaceAll("\\{" + "order_id" + "\\}", orderId.toString());
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+        TypeReference<Order> localVarReturnType = new TypeReference<Order>() {};
+        apiClient.invokeAPI(localVarPath, "GET", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+    /**
+     * Place an order for a pet
+     * 
+     * @param body order placed for purchasing the pet (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void placeOrder(Order body, Handler<AsyncResult<Order>> resultHandler) {
+        Object localVarBody = body;
+        
+        // verify the required parameter 'body' is set
+        if (body == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'body' when calling placeOrder"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/store/order";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+        TypeReference<Order> localVarReturnType = new TypeReference<Order>() {};
+        apiClient.invokeAPI(localVarPath, "POST", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/UserApi.java

@@ -0,0 +1,28 @@
+package io.swagger.client.api;
+
+import io.swagger.client.model.User;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.json.JsonObject;
+
+import java.util.*;
+
+public interface UserApi {
+
+    void createUser(User body, Handler<AsyncResult<Void>> handler);
+
+    void createUsersWithArrayInput(List<User> body, Handler<AsyncResult<Void>> handler);
+
+    void createUsersWithListInput(List<User> body, Handler<AsyncResult<Void>> handler);
+
+    void deleteUser(String username, Handler<AsyncResult<Void>> handler);
+
+    void getUserByName(String username, Handler<AsyncResult<User>> handler);
+
+    void loginUser(String username, String password, Handler<AsyncResult<String>> handler);
+
+    void logoutUser(Handler<AsyncResult<Void>> handler);
+
+    void updateUser(String username, User body, Handler<AsyncResult<Void>> handler);
+
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/UserApiImpl.java

@@ -0,0 +1,321 @@
+package io.swagger.client.api;
+
+import io.swagger.client.model.User;
+
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.json.JsonObject;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+
+import java.util.*;
+
+import io.swagger.client.ApiClient;
+import io.swagger.client.ApiException;
+import io.swagger.client.Configuration;
+import io.swagger.client.Pair;
+
+
+public class UserApiImpl implements UserApi {
+
+    private ApiClient apiClient;
+
+    public UserApiImpl() {
+        this(null);
+    }
+
+    public UserApiImpl(ApiClient apiClient) {
+        this.apiClient = apiClient != null ? apiClient : Configuration.getDefaultApiClient();
+    }
+
+    public ApiClient getApiClient() {
+        return apiClient;
+    }
+
+    public void setApiClient(ApiClient apiClient) {
+        this.apiClient = apiClient;
+    }
+
+    /**
+     * Create user
+     * This can only be done by the logged in user.
+     * @param body Created user object (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void createUser(User body, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = body;
+        
+        // verify the required parameter 'body' is set
+        if (body == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'body' when calling createUser"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/user";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+
+        apiClient.invokeAPI(localVarPath, "POST", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+    /**
+     * Creates list of users with given input array
+     * 
+     * @param body List of user object (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void createUsersWithArrayInput(List<User> body, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = body;
+        
+        // verify the required parameter 'body' is set
+        if (body == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'body' when calling createUsersWithArrayInput"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/user/createWithArray";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+
+        apiClient.invokeAPI(localVarPath, "POST", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+    /**
+     * Creates list of users with given input array
+     * 
+     * @param body List of user object (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void createUsersWithListInput(List<User> body, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = body;
+        
+        // verify the required parameter 'body' is set
+        if (body == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'body' when calling createUsersWithListInput"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/user/createWithList";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+
+        apiClient.invokeAPI(localVarPath, "POST", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+    /**
+     * Delete user
+     * This can only be done by the logged in user.
+     * @param username The name that needs to be deleted (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void deleteUser(String username, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'username' is set
+        if (username == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'username' when calling deleteUser"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/user/{username}".replaceAll("\\{" + "username" + "\\}", username.toString());
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+
+        apiClient.invokeAPI(localVarPath, "DELETE", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+    /**
+     * Get user by user name
+     * 
+     * @param username The name that needs to be fetched. Use user1 for testing.  (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void getUserByName(String username, Handler<AsyncResult<User>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'username' is set
+        if (username == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'username' when calling getUserByName"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/user/{username}".replaceAll("\\{" + "username" + "\\}", username.toString());
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+        TypeReference<User> localVarReturnType = new TypeReference<User>() {};
+        apiClient.invokeAPI(localVarPath, "GET", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+    /**
+     * Logs user into the system
+     * 
+     * @param username The user name for login (required)
+     * @param password The password for login in clear text (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void loginUser(String username, String password, Handler<AsyncResult<String>> resultHandler) {
+        Object localVarBody = null;
+        
+        // verify the required parameter 'username' is set
+        if (username == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'username' when calling loginUser"));
+            return;
+        }
+        
+        // verify the required parameter 'password' is set
+        if (password == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'password' when calling loginUser"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/user/login";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+        localVarQueryParams.addAll(apiClient.parameterToPairs("", "username", username));
+        localVarQueryParams.addAll(apiClient.parameterToPairs("", "password", password));
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+        TypeReference<String> localVarReturnType = new TypeReference<String>() {};
+        apiClient.invokeAPI(localVarPath, "GET", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, localVarReturnType, resultHandler);
+    }
+    /**
+     * Logs out current logged in user session
+     * 
+     * @param resultHandler Asynchronous result handler
+     */
+    public void logoutUser(Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = null;
+        
+        // create path and map variables
+        String localVarPath = "/user/logout";
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+
+        apiClient.invokeAPI(localVarPath, "GET", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+    /**
+     * Updated user
+     * This can only be done by the logged in user.
+     * @param username name that need to be deleted (required)
+     * @param body Updated user object (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void updateUser(String username, User body, Handler<AsyncResult<Void>> resultHandler) {
+        Object localVarBody = body;
+        
+        // verify the required parameter 'username' is set
+        if (username == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'username' when calling updateUser"));
+            return;
+        }
+        
+        // verify the required parameter 'body' is set
+        if (body == null) {
+            resultHandler.handle(ApiException.fail(400, "Missing the required parameter 'body' when calling updateUser"));
+            return;
+        }
+        
+        // create path and map variables
+        String localVarPath = "/user/{username}".replaceAll("\\{" + "username" + "\\}", username.toString());
+
+        // query params
+        List<Pair> localVarQueryParams = new ArrayList<>();
+
+        // header params
+        MultiMap localVarHeaderParams = MultiMap.caseInsensitiveMultiMap();
+        
+        // form params
+        // TODO: sending files within multipart/form-data is not supported yet (because of vertx web-client)
+        Map<String, Object> localVarFormParams = new HashMap<>();
+        
+        String[] localVarAccepts = { "application/xml", "application/json" };
+        String[] localVarContentTypes = {  };
+        String[] localVarAuthNames = new String[] {  };
+
+        apiClient.invokeAPI(localVarPath, "PUT", localVarQueryParams, localVarBody, localVarHeaderParams, localVarFormParams, localVarAccepts, localVarContentTypes, localVarAuthNames, null, resultHandler);
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/rxjava/FakeApi.java

@@ -0,0 +1,242 @@
+package io.swagger.client.api.rxjava;
+
+import java.math.BigDecimal;
+import io.swagger.client.model.Client;
+import org.threeten.bp.LocalDate;
+import org.threeten.bp.OffsetDateTime;
+import io.swagger.client.model.OuterComposite;
+
+import java.util.*;
+
+import rx.Single;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+
+
+public class FakeApi {
+
+	private final io.swagger.client.api.FakeApi delegate;
+
+	public FakeApi(io.swagger.client.api.FakeApi delegate) {
+	    this.delegate = delegate;
+    }
+
+	public io.swagger.client.api.FakeApi getDelegate() {
+	    return delegate;
+	}
+
+    /**
+     * 
+     * Test serialization of outer boolean types
+     * @param body Input boolean as post body (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void fakeOuterBooleanSerialize(Boolean body, Handler<AsyncResult<Boolean>> resultHandler) {
+        delegate.fakeOuterBooleanSerialize(body, resultHandler);
+    }
+
+    /**
+     * 
+     * Test serialization of outer boolean types
+     * @param body Input boolean as post body (optional)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Boolean> rxFakeOuterBooleanSerialize(Boolean body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.fakeOuterBooleanSerialize(body, fut);
+        }));
+    }
+    /**
+     * 
+     * Test serialization of object with outer number type
+     * @param body Input composite as post body (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void fakeOuterCompositeSerialize(OuterComposite body, Handler<AsyncResult<OuterComposite>> resultHandler) {
+        delegate.fakeOuterCompositeSerialize(body, resultHandler);
+    }
+
+    /**
+     * 
+     * Test serialization of object with outer number type
+     * @param body Input composite as post body (optional)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<OuterComposite> rxFakeOuterCompositeSerialize(OuterComposite body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.fakeOuterCompositeSerialize(body, fut);
+        }));
+    }
+    /**
+     * 
+     * Test serialization of outer number types
+     * @param body Input number as post body (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void fakeOuterNumberSerialize(BigDecimal body, Handler<AsyncResult<BigDecimal>> resultHandler) {
+        delegate.fakeOuterNumberSerialize(body, resultHandler);
+    }
+
+    /**
+     * 
+     * Test serialization of outer number types
+     * @param body Input number as post body (optional)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<BigDecimal> rxFakeOuterNumberSerialize(BigDecimal body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.fakeOuterNumberSerialize(body, fut);
+        }));
+    }
+    /**
+     * 
+     * Test serialization of outer string types
+     * @param body Input string as post body (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void fakeOuterStringSerialize(String body, Handler<AsyncResult<String>> resultHandler) {
+        delegate.fakeOuterStringSerialize(body, resultHandler);
+    }
+
+    /**
+     * 
+     * Test serialization of outer string types
+     * @param body Input string as post body (optional)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<String> rxFakeOuterStringSerialize(String body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.fakeOuterStringSerialize(body, fut);
+        }));
+    }
+    /**
+     * To test \&quot;client\&quot; model
+     * To test \&quot;client\&quot; model
+     * @param body client model (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void testClientModel(Client body, Handler<AsyncResult<Client>> resultHandler) {
+        delegate.testClientModel(body, resultHandler);
+    }
+
+    /**
+     * To test \&quot;client\&quot; model
+     * To test \&quot;client\&quot; model
+     * @param body client model (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Client> rxTestClientModel(Client body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.testClientModel(body, fut);
+        }));
+    }
+    /**
+     * Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+     * Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+     * @param number None (required)
+     * @param _double None (required)
+     * @param patternWithoutDelimiter None (required)
+     * @param _byte None (required)
+     * @param integer None (optional)
+     * @param int32 None (optional)
+     * @param int64 None (optional)
+     * @param _float None (optional)
+     * @param string None (optional)
+     * @param binary None (optional)
+     * @param date None (optional)
+     * @param dateTime None (optional)
+     * @param password None (optional)
+     * @param paramCallback None (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void testEndpointParameters(BigDecimal number, Double _double, String patternWithoutDelimiter, byte[] _byte, Integer integer, Integer int32, Long int64, Float _float, String string, byte[] binary, LocalDate date, OffsetDateTime dateTime, String password, String paramCallback, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.testEndpointParameters(number, _double, patternWithoutDelimiter, _byte, integer, int32, int64, _float, string, binary, date, dateTime, password, paramCallback, resultHandler);
+    }
+
+    /**
+     * Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+     * Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+     * @param number None (required)
+     * @param _double None (required)
+     * @param patternWithoutDelimiter None (required)
+     * @param _byte None (required)
+     * @param integer None (optional)
+     * @param int32 None (optional)
+     * @param int64 None (optional)
+     * @param _float None (optional)
+     * @param string None (optional)
+     * @param binary None (optional)
+     * @param date None (optional)
+     * @param dateTime None (optional)
+     * @param password None (optional)
+     * @param paramCallback None (optional)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxTestEndpointParameters(BigDecimal number, Double _double, String patternWithoutDelimiter, byte[] _byte, Integer integer, Integer int32, Long int64, Float _float, String string, byte[] binary, LocalDate date, OffsetDateTime dateTime, String password, String paramCallback) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.testEndpointParameters(number, _double, patternWithoutDelimiter, _byte, integer, int32, int64, _float, string, binary, date, dateTime, password, paramCallback, fut);
+        }));
+    }
+    /**
+     * To test enum parameters
+     * To test enum parameters
+     * @param enumFormStringArray Form parameter enum test (string array) (optional)
+     * @param enumFormString Form parameter enum test (string) (optional, default to -efg)
+     * @param enumHeaderStringArray Header parameter enum test (string array) (optional)
+     * @param enumHeaderString Header parameter enum test (string) (optional, default to -efg)
+     * @param enumQueryStringArray Query parameter enum test (string array) (optional)
+     * @param enumQueryString Query parameter enum test (string) (optional, default to -efg)
+     * @param enumQueryInteger Query parameter enum test (double) (optional)
+     * @param enumQueryDouble Query parameter enum test (double) (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void testEnumParameters(List<String> enumFormStringArray, String enumFormString, List<String> enumHeaderStringArray, String enumHeaderString, List<String> enumQueryStringArray, String enumQueryString, Integer enumQueryInteger, Double enumQueryDouble, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.testEnumParameters(enumFormStringArray, enumFormString, enumHeaderStringArray, enumHeaderString, enumQueryStringArray, enumQueryString, enumQueryInteger, enumQueryDouble, resultHandler);
+    }
+
+    /**
+     * To test enum parameters
+     * To test enum parameters
+     * @param enumFormStringArray Form parameter enum test (string array) (optional)
+     * @param enumFormString Form parameter enum test (string) (optional, default to -efg)
+     * @param enumHeaderStringArray Header parameter enum test (string array) (optional)
+     * @param enumHeaderString Header parameter enum test (string) (optional, default to -efg)
+     * @param enumQueryStringArray Query parameter enum test (string array) (optional)
+     * @param enumQueryString Query parameter enum test (string) (optional, default to -efg)
+     * @param enumQueryInteger Query parameter enum test (double) (optional)
+     * @param enumQueryDouble Query parameter enum test (double) (optional)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxTestEnumParameters(List<String> enumFormStringArray, String enumFormString, List<String> enumHeaderStringArray, String enumHeaderString, List<String> enumQueryStringArray, String enumQueryString, Integer enumQueryInteger, Double enumQueryDouble) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.testEnumParameters(enumFormStringArray, enumFormString, enumHeaderStringArray, enumHeaderString, enumQueryStringArray, enumQueryString, enumQueryInteger, enumQueryDouble, fut);
+        }));
+    }
+    /**
+     * test json serialization of form data
+     * 
+     * @param param field1 (required)
+     * @param param2 field2 (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void testJsonFormData(String param, String param2, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.testJsonFormData(param, param2, resultHandler);
+    }
+
+    /**
+     * test json serialization of form data
+     * 
+     * @param param field1 (required)
+     * @param param2 field2 (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxTestJsonFormData(String param, String param2) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.testJsonFormData(param, param2, fut);
+        }));
+    }
+
+    public static FakeApi newInstance(io.swagger.client.api.FakeApi arg) {
+        return arg != null ? new FakeApi(arg) : null;
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/rxjava/FakeClassnameTags123Api.java

@@ -0,0 +1,49 @@
+package io.swagger.client.api.rxjava;
+
+import io.swagger.client.model.Client;
+
+import java.util.*;
+
+import rx.Single;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+
+
+public class FakeClassnameTags123Api {
+
+	private final io.swagger.client.api.FakeClassnameTags123Api delegate;
+
+	public FakeClassnameTags123Api(io.swagger.client.api.FakeClassnameTags123Api delegate) {
+	    this.delegate = delegate;
+    }
+
+	public io.swagger.client.api.FakeClassnameTags123Api getDelegate() {
+	    return delegate;
+	}
+
+    /**
+     * To test class name in snake case
+     * 
+     * @param body client model (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void testClassname(Client body, Handler<AsyncResult<Client>> resultHandler) {
+        delegate.testClassname(body, resultHandler);
+    }
+
+    /**
+     * To test class name in snake case
+     * 
+     * @param body client model (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Client> rxTestClassname(Client body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.testClassname(body, fut);
+        }));
+    }
+
+    public static FakeClassnameTags123Api newInstance(io.swagger.client.api.FakeClassnameTags123Api arg) {
+        return arg != null ? new FakeClassnameTags123Api(arg) : null;
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/rxjava/PetApi.java

@@ -0,0 +1,208 @@
+package io.swagger.client.api.rxjava;
+
+import io.vertx.core.file.AsyncFile;
+import io.swagger.client.model.ModelApiResponse;
+import io.swagger.client.model.Pet;
+
+import java.util.*;
+
+import rx.Single;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+
+
+public class PetApi {
+
+	private final io.swagger.client.api.PetApi delegate;
+
+	public PetApi(io.swagger.client.api.PetApi delegate) {
+	    this.delegate = delegate;
+    }
+
+	public io.swagger.client.api.PetApi getDelegate() {
+	    return delegate;
+	}
+
+    /**
+     * Add a new pet to the store
+     * 
+     * @param body Pet object that needs to be added to the store (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void addPet(Pet body, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.addPet(body, resultHandler);
+    }
+
+    /**
+     * Add a new pet to the store
+     * 
+     * @param body Pet object that needs to be added to the store (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxAddPet(Pet body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.addPet(body, fut);
+        }));
+    }
+    /**
+     * Deletes a pet
+     * 
+     * @param petId Pet id to delete (required)
+     * @param apiKey  (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void deletePet(Long petId, String apiKey, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.deletePet(petId, apiKey, resultHandler);
+    }
+
+    /**
+     * Deletes a pet
+     * 
+     * @param petId Pet id to delete (required)
+     * @param apiKey  (optional)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxDeletePet(Long petId, String apiKey) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.deletePet(petId, apiKey, fut);
+        }));
+    }
+    /**
+     * Finds Pets by status
+     * Multiple status values can be provided with comma separated strings
+     * @param status Status values that need to be considered for filter (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void findPetsByStatus(List<String> status, Handler<AsyncResult<List<Pet>>> resultHandler) {
+        delegate.findPetsByStatus(status, resultHandler);
+    }
+
+    /**
+     * Finds Pets by status
+     * Multiple status values can be provided with comma separated strings
+     * @param status Status values that need to be considered for filter (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<List<Pet>> rxFindPetsByStatus(List<String> status) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.findPetsByStatus(status, fut);
+        }));
+    }
+    /**
+     * Finds Pets by tags
+     * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+     * @param tags Tags to filter by (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void findPetsByTags(List<String> tags, Handler<AsyncResult<List<Pet>>> resultHandler) {
+        delegate.findPetsByTags(tags, resultHandler);
+    }
+
+    /**
+     * Finds Pets by tags
+     * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+     * @param tags Tags to filter by (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<List<Pet>> rxFindPetsByTags(List<String> tags) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.findPetsByTags(tags, fut);
+        }));
+    }
+    /**
+     * Find pet by ID
+     * Returns a single pet
+     * @param petId ID of pet to return (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void getPetById(Long petId, Handler<AsyncResult<Pet>> resultHandler) {
+        delegate.getPetById(petId, resultHandler);
+    }
+
+    /**
+     * Find pet by ID
+     * Returns a single pet
+     * @param petId ID of pet to return (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Pet> rxGetPetById(Long petId) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.getPetById(petId, fut);
+        }));
+    }
+    /**
+     * Update an existing pet
+     * 
+     * @param body Pet object that needs to be added to the store (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void updatePet(Pet body, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.updatePet(body, resultHandler);
+    }
+
+    /**
+     * Update an existing pet
+     * 
+     * @param body Pet object that needs to be added to the store (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxUpdatePet(Pet body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.updatePet(body, fut);
+        }));
+    }
+    /**
+     * Updates a pet in the store with form data
+     * 
+     * @param petId ID of pet that needs to be updated (required)
+     * @param name Updated name of the pet (optional)
+     * @param status Updated status of the pet (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void updatePetWithForm(Long petId, String name, String status, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.updatePetWithForm(petId, name, status, resultHandler);
+    }
+
+    /**
+     * Updates a pet in the store with form data
+     * 
+     * @param petId ID of pet that needs to be updated (required)
+     * @param name Updated name of the pet (optional)
+     * @param status Updated status of the pet (optional)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxUpdatePetWithForm(Long petId, String name, String status) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.updatePetWithForm(petId, name, status, fut);
+        }));
+    }
+    /**
+     * uploads an image
+     * 
+     * @param petId ID of pet to update (required)
+     * @param additionalMetadata Additional data to pass to server (optional)
+     * @param file file to upload (optional)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void uploadFile(Long petId, String additionalMetadata, AsyncFile file, Handler<AsyncResult<ModelApiResponse>> resultHandler) {
+        delegate.uploadFile(petId, additionalMetadata, file, resultHandler);
+    }
+
+    /**
+     * uploads an image
+     * 
+     * @param petId ID of pet to update (required)
+     * @param additionalMetadata Additional data to pass to server (optional)
+     * @param file file to upload (optional)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<ModelApiResponse> rxUploadFile(Long petId, String additionalMetadata, AsyncFile file) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.uploadFile(petId, additionalMetadata, file, fut);
+        }));
+    }
+
+    public static PetApi newInstance(io.swagger.client.api.PetApi arg) {
+        return arg != null ? new PetApi(arg) : null;
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/rxjava/StoreApi.java

@@ -0,0 +1,110 @@
+package io.swagger.client.api.rxjava;
+
+import io.swagger.client.model.Order;
+
+import java.util.*;
+
+import rx.Single;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+
+
+public class StoreApi {
+
+	private final io.swagger.client.api.StoreApi delegate;
+
+	public StoreApi(io.swagger.client.api.StoreApi delegate) {
+	    this.delegate = delegate;
+    }
+
+	public io.swagger.client.api.StoreApi getDelegate() {
+	    return delegate;
+	}
+
+    /**
+     * Delete purchase order by ID
+     * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+     * @param orderId ID of the order that needs to be deleted (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void deleteOrder(String orderId, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.deleteOrder(orderId, resultHandler);
+    }
+
+    /**
+     * Delete purchase order by ID
+     * For valid response try integer IDs with value &lt; 1000. Anything above 1000 or nonintegers will generate API errors
+     * @param orderId ID of the order that needs to be deleted (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxDeleteOrder(String orderId) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.deleteOrder(orderId, fut);
+        }));
+    }
+    /**
+     * Returns pet inventories by status
+     * Returns a map of status codes to quantities
+     * @param resultHandler Asynchronous result handler
+     */
+    public void getInventory(Handler<AsyncResult<Map<String, Integer>>> resultHandler) {
+        delegate.getInventory(resultHandler);
+    }
+
+    /**
+     * Returns pet inventories by status
+     * Returns a map of status codes to quantities
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Map<String, Integer>> rxGetInventory() {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.getInventory(fut);
+        }));
+    }
+    /**
+     * Find purchase order by ID
+     * For valid response try integer IDs with value &lt;&#x3D; 5 or &gt; 10. Other values will generated exceptions
+     * @param orderId ID of pet that needs to be fetched (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void getOrderById(Long orderId, Handler<AsyncResult<Order>> resultHandler) {
+        delegate.getOrderById(orderId, resultHandler);
+    }
+
+    /**
+     * Find purchase order by ID
+     * For valid response try integer IDs with value &lt;&#x3D; 5 or &gt; 10. Other values will generated exceptions
+     * @param orderId ID of pet that needs to be fetched (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Order> rxGetOrderById(Long orderId) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.getOrderById(orderId, fut);
+        }));
+    }
+    /**
+     * Place an order for a pet
+     * 
+     * @param body order placed for purchasing the pet (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void placeOrder(Order body, Handler<AsyncResult<Order>> resultHandler) {
+        delegate.placeOrder(body, resultHandler);
+    }
+
+    /**
+     * Place an order for a pet
+     * 
+     * @param body order placed for purchasing the pet (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Order> rxPlaceOrder(Order body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.placeOrder(body, fut);
+        }));
+    }
+
+    public static StoreApi newInstance(io.swagger.client.api.StoreApi arg) {
+        return arg != null ? new StoreApi(arg) : null;
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/api/rxjava/UserApi.java

@@ -0,0 +1,198 @@
+package io.swagger.client.api.rxjava;
+
+import io.swagger.client.model.User;
+
+import java.util.*;
+
+import rx.Single;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
+
+
+public class UserApi {
+
+	private final io.swagger.client.api.UserApi delegate;
+
+	public UserApi(io.swagger.client.api.UserApi delegate) {
+	    this.delegate = delegate;
+    }
+
+	public io.swagger.client.api.UserApi getDelegate() {
+	    return delegate;
+	}
+
+    /**
+     * Create user
+     * This can only be done by the logged in user.
+     * @param body Created user object (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void createUser(User body, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.createUser(body, resultHandler);
+    }
+
+    /**
+     * Create user
+     * This can only be done by the logged in user.
+     * @param body Created user object (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxCreateUser(User body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.createUser(body, fut);
+        }));
+    }
+    /**
+     * Creates list of users with given input array
+     * 
+     * @param body List of user object (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void createUsersWithArrayInput(List<User> body, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.createUsersWithArrayInput(body, resultHandler);
+    }
+
+    /**
+     * Creates list of users with given input array
+     * 
+     * @param body List of user object (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxCreateUsersWithArrayInput(List<User> body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.createUsersWithArrayInput(body, fut);
+        }));
+    }
+    /**
+     * Creates list of users with given input array
+     * 
+     * @param body List of user object (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void createUsersWithListInput(List<User> body, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.createUsersWithListInput(body, resultHandler);
+    }
+
+    /**
+     * Creates list of users with given input array
+     * 
+     * @param body List of user object (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxCreateUsersWithListInput(List<User> body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.createUsersWithListInput(body, fut);
+        }));
+    }
+    /**
+     * Delete user
+     * This can only be done by the logged in user.
+     * @param username The name that needs to be deleted (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void deleteUser(String username, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.deleteUser(username, resultHandler);
+    }
+
+    /**
+     * Delete user
+     * This can only be done by the logged in user.
+     * @param username The name that needs to be deleted (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxDeleteUser(String username) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.deleteUser(username, fut);
+        }));
+    }
+    /**
+     * Get user by user name
+     * 
+     * @param username The name that needs to be fetched. Use user1 for testing.  (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void getUserByName(String username, Handler<AsyncResult<User>> resultHandler) {
+        delegate.getUserByName(username, resultHandler);
+    }
+
+    /**
+     * Get user by user name
+     * 
+     * @param username The name that needs to be fetched. Use user1 for testing.  (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<User> rxGetUserByName(String username) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.getUserByName(username, fut);
+        }));
+    }
+    /**
+     * Logs user into the system
+     * 
+     * @param username The user name for login (required)
+     * @param password The password for login in clear text (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void loginUser(String username, String password, Handler<AsyncResult<String>> resultHandler) {
+        delegate.loginUser(username, password, resultHandler);
+    }
+
+    /**
+     * Logs user into the system
+     * 
+     * @param username The user name for login (required)
+     * @param password The password for login in clear text (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<String> rxLoginUser(String username, String password) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.loginUser(username, password, fut);
+        }));
+    }
+    /**
+     * Logs out current logged in user session
+     * 
+     * @param resultHandler Asynchronous result handler
+     */
+    public void logoutUser(Handler<AsyncResult<Void>> resultHandler) {
+        delegate.logoutUser(resultHandler);
+    }
+
+    /**
+     * Logs out current logged in user session
+     * 
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxLogoutUser() {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.logoutUser(fut);
+        }));
+    }
+    /**
+     * Updated user
+     * This can only be done by the logged in user.
+     * @param username name that need to be deleted (required)
+     * @param body Updated user object (required)
+     * @param resultHandler Asynchronous result handler
+     */
+    public void updateUser(String username, User body, Handler<AsyncResult<Void>> resultHandler) {
+        delegate.updateUser(username, body, resultHandler);
+    }
+
+    /**
+     * Updated user
+     * This can only be done by the logged in user.
+     * @param username name that need to be deleted (required)
+     * @param body Updated user object (required)
+     * @return Asynchronous result handler (RxJava Single)
+     */
+    public Single<Void> rxUpdateUser(String username, User body) {
+        return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
+            delegate.updateUser(username, body, fut);
+        }));
+    }
+
+    public static UserApi newInstance(io.swagger.client.api.UserApi arg) {
+        return arg != null ? new UserApi(arg) : null;
+    }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/auth/ApiKeyAuth.java

@@ -0,0 +1,75 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+package io.swagger.client.auth;
+
+import io.swagger.client.Pair;
+import io.vertx.core.MultiMap;
+
+import java.util.List;
+
+
+public class ApiKeyAuth implements Authentication {
+  private final String location;
+  private final String paramName;
+
+  private String apiKey;
+  private String apiKeyPrefix;
+
+  public ApiKeyAuth(String location, String paramName) {
+    this.location = location;
+    this.paramName = paramName;
+  }
+
+  public String getLocation() {
+    return location;
+  }
+
+  public String getParamName() {
+    return paramName;
+  }
+
+  public String getApiKey() {
+    return apiKey;
+  }
+
+  public void setApiKey(String apiKey) {
+    this.apiKey = apiKey;
+  }
+
+  public String getApiKeyPrefix() {
+    return apiKeyPrefix;
+  }
+
+  public void setApiKeyPrefix(String apiKeyPrefix) {
+    this.apiKeyPrefix = apiKeyPrefix;
+  }
+
+  @Override
+  public void applyToParams(List<Pair> queryParams, MultiMap headerParams) {
+    if (apiKey == null) {
+      return;
+    }
+    String value;
+    if (apiKeyPrefix != null) {
+      value = apiKeyPrefix + " " + apiKey;
+    } else {
+      value = apiKey;
+    }
+    if ("query".equals(location)) {
+      queryParams.add(new Pair(paramName, value));
+    } else if ("header".equals(location)) {
+      headerParams.add(paramName, value);
+    }
+  }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/auth/Authentication.java

@@ -0,0 +1,29 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+package io.swagger.client.auth;
+
+import io.swagger.client.Pair;
+import io.vertx.core.MultiMap;
+
+import java.util.List;
+
+public interface Authentication {
+    /**
+     * Apply authentication settings to header and query params.
+     *
+     * @param queryParams List of query parameters
+     * @param headerParams Map of header parameters
+     */
+    void applyToParams(List<Pair> queryParams, MultiMap headerParams);
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/auth/HttpBasicAuth.java

@@ -0,0 +1,51 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+package io.swagger.client.auth;
+
+import io.swagger.client.Pair;
+import io.vertx.core.MultiMap;
+import java.util.Base64;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+
+public class HttpBasicAuth implements Authentication {
+  private String username;
+  private String password;
+
+  public String getUsername() {
+    return username;
+  }
+
+  public void setUsername(String username) {
+    this.username = username;
+  }
+
+  public String getPassword() {
+    return password;
+  }
+
+  public void setPassword(String password) {
+    this.password = password;
+  }
+
+  @Override
+  public void applyToParams(List<Pair> queryParams, MultiMap headerParams) {
+    if (username == null && password == null) {
+      return;
+    }
+    String str = (username == null ? "" : username) + ":" + (password == null ? "" : password);
+    headerParams.add("Authorization", "Basic " + Base64.getEncoder().encodeToString(str.getBytes(StandardCharsets.UTF_8)));
+  }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/auth/OAuth.java

@@ -0,0 +1,39 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+package io.swagger.client.auth;
+
+import io.swagger.client.Pair;
+import io.vertx.core.MultiMap;
+
+import java.util.List;
+
+
+public class OAuth implements Authentication {
+  private String accessToken;
+
+  public String getAccessToken() {
+    return accessToken;
+  }
+
+  public void setAccessToken(String accessToken) {
+    this.accessToken = accessToken;
+  }
+
+  @Override
+  public void applyToParams(List<Pair> queryParams, MultiMap headerParams) {
+    if (accessToken != null) {
+      headerParams.add("Authorization", "Bearer " + accessToken);
+    }
+  }
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/auth/OAuthFlow.java

@@ -0,0 +1,18 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+package io.swagger.client.auth;
+
+public enum OAuthFlow {
+    accessCode, implicit, password, application
+}

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/model/AdditionalPropertiesClass.java

@@ -0,0 +1,132 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+package io.swagger.client.model;
+
+import java.util.Objects;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * AdditionalPropertiesClass
+ */
+
+public class AdditionalPropertiesClass {
+  @JsonProperty("map_property")
+  private Map<String, String> mapProperty = null;
+
+  @JsonProperty("map_of_map_property")
+  private Map<String, Map<String, String>> mapOfMapProperty = null;
+
+  public AdditionalPropertiesClass mapProperty(Map<String, String> mapProperty) {
+    this.mapProperty = mapProperty;
+    return this;
+  }
+
+  public AdditionalPropertiesClass putMapPropertyItem(String key, String mapPropertyItem) {
+    if (this.mapProperty == null) {
+      this.mapProperty = new HashMap<String, String>();
+    }
+    this.mapProperty.put(key, mapPropertyItem);
+    return this;
+  }
+
+   /**
+   * Get mapProperty
+   * @return mapProperty
+  **/
+  @ApiModelProperty(value = "")
+  public Map<String, String> getMapProperty() {
+    return mapProperty;
+  }
+
+  public void setMapProperty(Map<String, String> mapProperty) {
+    this.mapProperty = mapProperty;
+  }
+
+  public AdditionalPropertiesClass mapOfMapProperty(Map<String, Map<String, String>> mapOfMapProperty) {
+    this.mapOfMapProperty = mapOfMapProperty;
+    return this;
+  }
+
+  public AdditionalPropertiesClass putMapOfMapPropertyItem(String key, Map<String, String> mapOfMapPropertyItem) {
+    if (this.mapOfMapProperty == null) {
+      this.mapOfMapProperty = new HashMap<String, Map<String, String>>();
+    }
+    this.mapOfMapProperty.put(key, mapOfMapPropertyItem);
+    return this;
+  }
+
+   /**
+   * Get mapOfMapProperty
+   * @return mapOfMapProperty
+  **/
+  @ApiModelProperty(value = "")
+  public Map<String, Map<String, String>> getMapOfMapProperty() {
+    return mapOfMapProperty;
+  }
+
+  public void setMapOfMapProperty(Map<String, Map<String, String>> mapOfMapProperty) {
+    this.mapOfMapProperty = mapOfMapProperty;
+  }
+
+
+  @Override
+  public boolean equals(java.lang.Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    AdditionalPropertiesClass additionalPropertiesClass = (AdditionalPropertiesClass) o;
+    return Objects.equals(this.mapProperty, additionalPropertiesClass.mapProperty) &&
+        Objects.equals(this.mapOfMapProperty, additionalPropertiesClass.mapOfMapProperty);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(mapProperty, mapOfMapProperty);
+  }
+
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    sb.append("class AdditionalPropertiesClass {\n");
+    
+    sb.append("    mapProperty: ").append(toIndentedString(mapProperty)).append("\n");
+    sb.append("    mapOfMapProperty: ").append(toIndentedString(mapOfMapProperty)).append("\n");
+    sb.append("}");
+    return sb.toString();
+  }
+
+  /**
+   * Convert the given object to string with each line indented by 4 spaces
+   * (except the first line).
+   */
+  private String toIndentedString(java.lang.Object o) {
+    if (o == null) {
+      return "null";
+    }
+    return o.toString().replace("\n", "\n    ");
+  }
+  
+}
+

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/model/Animal.java

@@ -0,0 +1,120 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+package io.swagger.client.model;
+
+import java.util.Objects;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.annotation.JsonValue;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+/**
+ * Animal
+ */
+@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "className", visible = true )
+@JsonSubTypes({
+  @JsonSubTypes.Type(value = Dog.class, name = "Dog"),
+  @JsonSubTypes.Type(value = Cat.class, name = "Cat"),
+})
+
+public class Animal {
+  @JsonProperty("className")
+  private String className = null;
+
+  @JsonProperty("color")
+  private String color = "red";
+
+  public Animal className(String className) {
+    this.className = className;
+    return this;
+  }
+
+   /**
+   * Get className
+   * @return className
+  **/
+  @ApiModelProperty(required = true, value = "")
+  public String getClassName() {
+    return className;
+  }
+
+  public void setClassName(String className) {
+    this.className = className;
+  }
+
+  public Animal color(String color) {
+    this.color = color;
+    return this;
+  }
+
+   /**
+   * Get color
+   * @return color
+  **/
+  @ApiModelProperty(value = "")
+  public String getColor() {
+    return color;
+  }
+
+  public void setColor(String color) {
+    this.color = color;
+  }
+
+
+  @Override
+  public boolean equals(java.lang.Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    Animal animal = (Animal) o;
+    return Objects.equals(this.className, animal.className) &&
+        Objects.equals(this.color, animal.color);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(className, color);
+  }
+
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    sb.append("class Animal {\n");
+    
+    sb.append("    className: ").append(toIndentedString(className)).append("\n");
+    sb.append("    color: ").append(toIndentedString(color)).append("\n");
+    sb.append("}");
+    return sb.toString();
+  }
+
+  /**
+   * Convert the given object to string with each line indented by 4 spaces
+   * (except the first line).
+   */
+  private String toIndentedString(java.lang.Object o) {
+    if (o == null) {
+      return "null";
+    }
+    return o.toString().replace("\n", "\n    ");
+  }
+  
+}
+

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/model/AnimalFarm.java

@@ -0,0 +1,65 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+package io.swagger.client.model;
+
+import java.util.Objects;
+import io.swagger.client.model.Animal;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * AnimalFarm
+ */
+
+public class AnimalFarm extends ArrayList<Animal> {
+
+  @Override
+  public boolean equals(java.lang.Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    return super.equals(o);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(super.hashCode());
+  }
+
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    sb.append("class AnimalFarm {\n");
+    sb.append("    ").append(toIndentedString(super.toString())).append("\n");
+    sb.append("}");
+    return sb.toString();
+  }
+
+  /**
+   * Convert the given object to string with each line indented by 4 spaces
+   * (except the first line).
+   */
+  private String toIndentedString(java.lang.Object o) {
+    if (o == null) {
+      return "null";
+    }
+    return o.toString().replace("\n", "\n    ");
+  }
+  
+}
+

samples/client/petstore/java/vertx/src/main/java/io/swagger/client/model/ArrayOfArrayOfNumberOnly.java

@@ -0,0 +1,101 @@
+/*
+ * Swagger Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * OpenAPI spec version: 1.0.0
+ * Contact: apiteam@swagger.io
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+package io.swagger.client.model;
+
+import java.util.Objects;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * ArrayOfArrayOfNumberOnly
+ */
+
+public class ArrayOfArrayOfNumberOnly {
+  @JsonProperty("ArrayArrayNumber")
+  private List<List<BigDecimal>> arrayArrayNumber = null;
+
+  public ArrayOfArrayOfNumberOnly arrayArrayNumber(List<List<BigDecimal>> arrayArrayNumber) {
+    this.arrayArrayNumber = arrayArrayNumber;
+    return this;
+  }
+
+  public ArrayOfArrayOfNumberOnly addArrayArrayNumberItem(List<BigDecimal> arrayArrayNumberItem) {
+    if (this.arrayArrayNumber == null) {
+      this.arrayArrayNumber = new ArrayList<List<BigDecimal>>();
+    }
+    this.arrayArrayNumber.add(arrayArrayNumberItem);
+    return this;
+  }
+
+   /**
+   * Get arrayArrayNumber
+   * @return arrayArrayNumber
+  **/
+  @ApiModelProperty(value = "")
+  public List<List<BigDecimal>> getArrayArrayNumber() {
+    return arrayArrayNumber;
+  }
+
+  public void setArrayArrayNumber(List<List<BigDecimal>> arrayArrayNumber) {
+    this.arrayArrayNumber = arrayArrayNumber;
+  }
+
+
+  @Override
+  public boolean equals(java.lang.Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    ArrayOfArrayOfNumberOnly arrayOfArrayOfNumberOnly = (ArrayOfArrayOfNumberOnly) o;
+    return Objects.equals(this.arrayArrayNumber, arrayOfArrayOfNumberOnly.arrayArrayNumber);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(arrayArrayNumber);
+  }
+
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    sb.append("class ArrayOfArrayOfNumberOnly {\n");
+    
+    sb.append("    arrayArrayNumber: ").append(toIndentedString(arrayArrayNumber)).append("\n");
+    sb.append("}");
+    return sb.toString();
+  }
+
+  /**
+   * Convert the given object to string with each line indented by 4 spaces
+   * (except the first line).
+   */
+  private String toIndentedString(java.lang.Object o) {
+    if (o == null) {
+      return "null";
+    }
+    return o.toString().replace("\n", "\n    ");
+  }
+  
+}
+